Model III ROM Explained - Part 3

Page Customization

Disassembly

0000 0105 0201 0301 0401 0500 0600 0701 0801 0900 0A02 0B00 0C02 0D01 0E02 0F02 1001 1102 1201 1300 1400 1500 1600 1700 1800 Tokenizer Explanation Reserved Words Error Messages 1901 1A01 1B00 1C00 1D01 1E01 1F02 2003 2100 2200 2301 2400 2501 2600 2701 2801 2900 2A02 2B01 2C01 2D00 2E01 2F01 3000 3100 3200 3300 3400 3502 3600 3701

Related Pages

Model III ROM Disassembly: 0000-0FFFH Model III ROM Disassembly: 1000-1FFFH Model III ROM Disassembly: 2000-2FFFH Model III ROM Disassembly: 3000-3FFFH Model III ROM Hex/Label Cross Reference Frank Durda's Proposed Model III ROM-C Rewrite

2003 - UE ERROR entry point.

2003-2004UEERR
LD E,26HLD E,ERRUE
Load register E with the ERROR code for a ?UE ERROR.
2005-2007GOERR
Go to the Level II BASIC error routine and display the appropriate error message.

2008-2038 - LEVEL II BASIC AUTO ROUTINE

THE AUTO [BEGGINNING LINE[,[INCREMENT]]] COMMAND IS USED TO AUTOMATICALLY GENERATE LINE NUMBERS FOR LINES TO BE INSERTED. BEGINNING LINE IS USED TO SPECIFY THE INITAL LINE (10 IS ASSUMED IF OMMITED) AND THE INCREMENT IS USED TO SPECIFY THE INCREMENT USED TO GENERATE THE NEXT LINE #. IF ONLY A COMMA IS USED AFTER THE BEGGINING LINE, THE OLD INCREMENT IS USED.

2008-200AAUTO
LD DE,000AH
Load DE with a default starting line number of ten.
200B
PUSH DE
Save the default stack line number in DE to the stack.
200C-200D
Jump down to 2025H if this is the end of the AUTO statement (meaning that no parameters were provided).
200E-2010
If we are here, then there were parameters after the AUTO statement so we need to GOSUB to 1E4FH to evaluate the line number at the current location of the BASIC program pointer in HL and return with the result in DE.
2011
EX DE,HL
Since there is no such Z-80 command as EX (SP),DE we now need to do some swapping to get DE into (SP). First, exchange the value of the line number in DE with the value of the current BASIC program pointer in HL.
2012
EX (SP),HL
Next, exchange the default line number (to the stack from the above push of DE) with the line number that the user provided (in HL).
2013-2014
Jump down to 2026H if this is the end of the AUTO statement (meaning that only 1 parameter was provided).
2015
EX DE,HL
Load HL with the value of the current BASIC program pointer in DE.
2016-2017
RST 08H ⇒ 2C
If we are here, then we have an AUTO command with one parameter (starting line number) and we have not finished with the command. Since the only valid addition to that would be a trailing ,, we need to test the current BASIC program pointer in HL for a COMMA (=2CH), by calling the COMPARE SYMBOL at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL register to the value in the location following the RST 08 call.
  • If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
  • If the two characters do not match, a syntax error message is given and control returns to the Input Phase).
2018
EX DE,HL
If we are here, then it matched (a ?SN ERROR would have occurred otherwise) so load DE with the value of the current BASIC program pointer in HL.
2019-201B
LD HL,(40E4H)LD HL,(AUTINC)
Load HL with the last AUTO increment value.
Note: 40E4H-40E5H holds AUTO increment.
201C
EX DE,HL
Exchange the value of the current BASIC program pointer in DE with the last AUTO increment value in HL.
201D-201E
Jump to 2025H if this is the end of the BASIC statement (meaning, we got AUTO nn, but no further parameter).
201F-2021
If we are here, there was a second parameter so we GOSUB to 1E5AH.
NOTE: The routine at 1E5A converts the ASCII string pointed to by HL to an integer deposited into DE. If the routine finds a non-numerica character, the conversion is stopped.
2022-2024
If that prior GOSUB found a non-numeric character it aborted with a NZ, so if there is a NZ, jump to 1997H to show a ?SN ERROR.
2025SNGAUT
EX DE,HL
Exchange the AUTO increment number in DE with the value of the current BASIC program pointer in HL.
2026SNGAU1
LD A,H
Load register A with the MSB of the AUTO increment number in register H. (This is step 1 of a test to see if HL is zero)
2027
OR L
Combine the LSB of the AUTO increment number in register L with the MSB of the AUTO increment number in register A. (This is step 2 of a test to see if HL is zero)
2028-202A
That all tested the value of HL to see if it was zero. If it was, jupm to 1E4AH to show a ?FC ERROR message.
202B-202D
LD (40E4H),HLLD (AUTINC),HL
Save the value of the AUTO increment number in HL.
Note: 40E4H-40E5H holds AUTO increment.
202E-2030
LD (40E1H),ALD (AUTFLG),A
Set the AUTO flag to non-zero. We know A is non-zero because we would have jumped 2 instruction ago if it was.
2031
POP HL
Get the starting line number from the stack and put it in HL.
2032-2034
LD (40E2H),HLLD (AUTLIN),HL
Save the line number in HL as the next AUTO line number.
Note: 40E2H-40E3H holds Current BASIC line number.
2035
POP BC
Clean up the stack.
2036-2038
Jump to the Level II BASIC command mode.

2039-2066 - LEVEL II BASIC IF ROUTINE

2039-203BIF
GOSUB to 2337H to evaluate the BASIC expression pointed to by HL and return with the result in REG 1.
203C
LD A,(HL)
Load register A with the character at the location of the current BASIC program pointer in HL.
203D-203E
CP 2CH
Check to see if the character at the location of the current BASIC program pointer in register A is a ,.

Notes:

  • 2C is a , in ASCII
  • A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
203F-2041
If the character at the location of the current BASIC program pointer in register A is a , then go bump the value of the current BASIC program pointer in HL until it points to the next character.
2042-2043
CP CAH
Check to see if the character at the location of the current BASIC program pointer in register A is a THEN token

Notes:

  • CAH is a THEN token.
  • A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
2044-2046
If Z flag is set, the character at the location of the current BASIC program pointer in register A is a THEN token, so we need to bump the value of the current BASIC program pointer until it points to the next character.
2047OKGOTO
DEC HL
Decrement the value of the current BASIC program pointer in HL so that we are still positioned at the THEN token.
2048
PUSH HL
Save the value of the current BASIC program pointer to the stack.
2049-204B
GOSUB to 0994H to see if the expression after the IF token was true or false.
204C
POP HL
Restore the address of the current position in the current statement (from the stack) into HL.
204D-204E
Jump down to 2056H if the expression was false.
204FDOCOND
RST 10H
We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2050-2052
Jump to the GOTO routine if the character at the location of the current BASIC program pointer in HL is numeric.
2053-2055
Jump to the execution driver at 1D5FH to evaluate the rest of the statement string.

2056 - LEVEL II BASIC ELSE ROUTINE

2056-2057FALSIF
LD D,01H
Load register D with the scan counter (as we will need to count the number of times to scan to the end of line).
2058-205ASKPMRF
Go scan the BASIC statement.
205B
OR A
Check to see if this is the end of the BASIC instruction.
205C
RET Z
Return if this is the end of the BASIC statement.
205D
RST 10H
We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
205E-205F
CP 95H
Check to see if the character at the location of the current BASIC program pointer in register A is an ELSE token.

Notes:

  • 95H is a ELSE in ASCII
  • A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
2060-2061
Loop back to 2058H until an ELSE token is found.
2062
DEC D
Decrement the value of the scan counter.
2063-2064
Loop back to 2058H until all of the ELSE tokens have been found.
2065-2066
Jump to 204FH to evaluate the rest of the expression.

2067-206E - LEVEL II BASIC LPRINT ROUTINE

2067-2068LPRINT
LD A,01H
Load register A with the output device code for the printer.
2069-206B
LD (409CH),ALD (PRTFLG),A
Save the value in register A as the current output device type number.
  • Note: 409CH holds the current output device flag:
    • -1=cassette,
    • 0=video; or
    • 1=printer.
*206C-206ELPRIN1
Skip a few instructions and pick up at 207CH.
Differences between M1 and M3 ROMs: All of the changes from 206DH - 20F7H first appeared in the "new" ROMs of the Model I. The changes were made to allow the use of multiple @'s in a PRINT statement.

206F-2177 - LEVEL II BASIC PRINT ROUTINE

206F-2071PRINT
Call the DOS exit link at 41CAH.
*2072-2073PNOTAT
CP '#'
Check the character at the location of the current BASIC program pointer in register A to see if it's an #.
*2074-2075
Jump to 207CH if it is not a #.
*2076-2078
GOSUB to 0284H to [Turn the tape on, no header].
*2079-207B
LD (409CH),ALD (PRTFLG),A
Load the memory location at 409CH with A, to route output to cassette.
*207CPNOTCS / NEWCHR
DEC HL
Decrement HL to back up.
*207D
RST 10H
We need to check for the end of the statement as the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
*207E-2080
GOSUB to 20FEH if it was the end of statement, so we can process a new line.
*2081-2083
And if it was the end of the statement then JUMP to 2169H to finish up.
*2084
OR 20H
With this MASK, we are getting readh to check to see if it was a @.
*2086
CP 60H
Compare against a "'" (which is actually a @ on the TRS-80).
*2088-2089
JUMP to 20A5H if it is not a @.
*208A
GOSUB to 2B01H to evaluate the PRINT@ expression (which is at the location of the current BASIC program pointer in HL and return with the result in DE).
*208D
Check to see if the location in DE is greater than 1023H. A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
*208F
If that check resulted in no CARRY flag, jump to 1E4AH to show a ?FC error.
*2092
PUSH HL
Push the current code string address (held in HL) to the stack.
*2093
LD HL,3C00H
Load HL with the start of the display area.
*2096
ADD HL,DE
Add DE to HL so that HL now will be the start of the diplay area PLUS the PRINT@ offset position.
*2097
LD (4020H),HLLD (CURSOR),HL
Store the cursor position of the screen address matching the PRINT@ position into the display DCB held in memory location 4020H.
  • 4020H-4021H: Holds the video memory address of the current cursor position.
*209A
LD A,E
E is the current position within the line.
*209B
AND 3FH
Make it not exceed 63 and then save it ....
*209D
LD (40A6H),ALD (TTYPOS),A
... into the current cursor offset (which is held in 40A6H).
*20A0
POP HL
Restore the code string address to HL
*20A2
RST 08H ⇒ 2C
At this point we have a PRINT@nnnn so the only valid next character is a , so we need to call RST 08H to check against 2C, the code for comma.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL register to the value in the location following the RST 08 call.
  • If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
  • If the two characters do not match, a syntax error message is given and control returns to the Input Phase).
*20A3-20A4
JUMP to 206CH to [NEXT ITEM].
*20A5
LD A,(HL)
2C
Put the next token (held in the memory location pointed to by HL) into A.
*20A6-20A7
CP 0BFHCP USINTK
Compare the device flag.
NOTE: A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
*20A8-20AA
... and return to the execution driver.
*20AB-20AC
CP 0BCHCP TABTK
Test for a TAB token.

Notes:

  • BCH is a TAB in ASCII
  • A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
*20AD-20AF
and if it is a TAB token (meaning the command is PRINT TAB, jump down to 2137H.
*20B0
PUSH HL
Continuing on a PRINT#, save the current position in the input stream into the stack.
*20B1-20B2
CP 2CH
Test for a ,.

Notes:

  • 2CH is a , in ASCII
  • A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
*20B3-20B4
If there is a comma, jump down to 2108H to get the next item.
*20B5-20B6
CP 3BH
Since its not a comma, next we need to check for a ;.

Notes:

  • 3BH is a ; in ASCII
  • A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
*20B7-20B8
If it is a ;, jump down to 2117H, which then jumps to NOTABR, to process. This is a break in the Bill Gates source code vs. the ROM as released. In the Bill Gates source code, this would have been a direct jump to NOTABR and 2117H has no label.
*20B9
GOSUB to 2337H [to evaluate the expression].
*20BC
EX(SP),HL
Swap (SP) for HL to restore the position.
20BD
RST 20H
Check its data type with a call to RST 20H.
NOTE: The RST 20H routine determines the type of the current value in REG 1 and returns a combination of STATUS flags and unique numeric values in the A Register according to the data mode flag (40AFH).

The results are returned as follows:
If the Variable Type is ...and the Flags
are set ...		... then Register
A will be set ...
IntegerNZ/C/M/E-1
StringZ/C/P/E0
Single PrecisionNZ/C/P/O1
Double PrecisionNZ/NC/P/E5
20BE
If it is a string, jump down to 20F2H.
20C0
GOSUB to the routine at 0FBDH to convert the binary to ASCII and move to the print buffer.
20C3
GOSUB to the routine at 2865H to build a literal string pool entry for the ASCII number.
20C6
GOSUB to a DOS exit if needed
20C9
LD HL,(4121H)LD HL,(FACLO)
Put the address of the current print string into HL.
20CC
LD A,(409CH)LD A,(PRTFLG)
Get the output device type flag and put it into A.
  • Note: 409CH holds the current output device flag:
    • -1=cassette,
    • 0=video; or
    • 1=printer.
20CF
OR A
Test the output device type flag.
20D0
If we writing to a cassette (i.e., PRINT#) jump to 20E9H.
20D3
If, instead, we do NOT have a LPRINT, jump down to 20DDH.
20D5-20D7LPTCD2
LD A,(409BH)LD A,(LPTPOS)
If we are here, we have a LPRINT so load A with the current carriage position.
Note: 409BH holds the printer carriage position.
20D8
ADD A,(HL)
Add the length of the string to be sent to the printer at the location of the memory pointer in HL to the current carriage position in register A.
20D9-20DA
CP 84HCP LPTLEN
Check to see if the adjusted length in register A is greater than 132.
NOTE: A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
20DB-20DC
Jump forward to 20E6H.
20DD-20DFISTTY
LD A,(409DH)LD A,(LINLEN)
Load register A with the video line size.
Note: 409DH holds the size of line on the video display.
20E0
LD B,A
Load register B with the video line size in register A.
20E1-20E3
LD A,(40A6H)LD A,(TTYPOS)
Load register A with the current video line position.
Note: 40A6H holds the current cursor line position.
20E4
ADD A,(HL)
Add the length of the string to be sent to the video display at the location of the memory pointer in HL to the value of the current video line position in register A.
20E5
CP B
Check to see if the length in register A is greater than the video line length.
NOTE: A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
20E6-20E8LINCHK
If NC is set, the new line will overflow the buffer so send a carriage return to the current output device.
20E9-20EBLINCH2
Go send the string to the current output device.
20EC-20ED
LD A,20H
Load register A with a space.
20EE-20F0
Go send the space in register A to the current output device.
20F1
OR A
Check to see if register A is equal to zero.
20F2-20F4STRDON
If necessary go send the string to the current output device.
20F5
POP HL
Restore the current code string to HL
20F6-20F8
Loop to 207CH until an end of statement code is found. Going all the way back to 207CH will also test for a PRINT @, thus permitting a PRINT @ to appear other than first.
20F9-20FBCRDONZ
LD A,(40A6H)LD A,(TTYPOS)
Load register A with the number of characters printed on the current line.
Note: 40A6H holds the current cursor line position.
20FC
OR A
Check to see if any characters have been printed on the current line.
20FD
RET Z
Return out of this routine if we are at the start of a line.

20FE - This routine outputs a carriage return (0DH) to a device determined by flag stored at (409CH)

NOTE: This routine may be CALLed at 20F9H, in which case it will not perform the above action if the video display cursor is already positioned at the beginning of a line, as determined by checking the contents of the cursor position flag at 40A6H (if zero, cursor is at start of line). This routine CALLs the routine at 032AH and also CALLs a Disk BASIC link at 41D0H.

20FE-20FFCRDO
LD A,0DH
Otherwise, we need to skip to the next line so load register A with a carriage return.
2100-2102
Go send the carriage return in register A to the current output device.
2103-2105CRFIN
Call the DOS link at 41D0H.
In NEWDOS 2.1, this is called when skipping to next line on a video during a BASIC output operation.
2106
XOR A
Zero register A and the carry flags.
2107
RET
Return back to the calling routine.

2108 - This is the jump point for a continuation of the "PRINT#" code

2108-210ACOMPRT
Call the DOS link at 4103H.
In NEWDOS 2.1, this is called at the start of PRINT on cassette and during PRINT TAB.
210B-210D
LD A,(409CH)LD A,(PRTFLG)
Load register A with the value of the current output device flag..
  • Note: 409CH holds the current output device flag:
    • -1=cassette,
    • 0=video; or
    • 1=printer.
210E
OR A
Test the value of the current output device flag in register A.
  • M will be set if the value in A is negative.
  • P will be set if the value in A is positive or zero.
210F-2111
Jump down a few instructions to 2119H if the printer or the video display is the current output device.
2112-2113
LD A,2CH
So now that we know the current device is cassette, we will load register A with a ,.
2114-2116
Send the , in register A to current output device. In this case, it is the cassette recorder because we otherwise would have jumped away at 210FH.
2117-2118
Jump forward to 2164H to fetch the next character from the code string.
2119-211ANTCCAS
We landed here from 210FH knowing that the current output device flag was either video or printer. Now we need to break that down too, so if the device flag is the video display, jump down to 2123H.
211B-211DLPTCD3
LD A,(409BH)LD A,(LPTPOS)
We're here because the output device is a printer. First, load register A with the current carriage position.
Note: 409BH holds the printer carriage position.
211E-211FNLPPOS
CP 70H
Check to see if the current carriage position in register A is greater than 112.
NOTE: A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
2120-2122
Jump forward a few instructions to 212BH.
2123-2125ISCTTY
LD A,(409EH)LD A,(CLMLST)
We were jumped to this point because the output device is the video display. So load register A with the video line length.
Note: 409EH holds the size of line on the printer.
2126
LD B,A
Load register B with the video line length in register A.
2127-2129
LD A,(40A6H)LD A,(TTYPOS)
Load register A with the current video line position.
Note: 40A6H holds the current cursor line position.
212ALINPT4
CP B
Test to see if there is room on this line by checking to see if the current video line position in register A is equal to the video line length in register B.
NOTE: A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
212B-212DCHKCOM
If the NC is set, there is no room on the current line, so we need to GOSUB to 20FEH to print a carriage return on the current output device.
212E-212F
If this is the end of the line on the current output device jump forward to 2164H.
2130-2131MORCOM
SUB 10HSUB CLMWID
Check to see if there are at least 16 spaces left on the current line for the current output device.
2132-2133
Loop back until there are at least 16 spaces left on the current line.
2134
CPL
Figure the number of spaces to be sent to the current output device.
2135-2136
Jump to 215AH to print those spaces/blanks.

2137 - TAB logic

This routine is the TAB function for video or printer (determined by flag at 409CH). On entry: E register contains desired TAB position, HL points to start of message to be displayed (or zero byte if no message). This routine does extensive string processing and may not be the most efficient method of achieving the desired result, particularly if it is desired only to tab over a number of spaces. Also, this routine CALLs several Disk BASIC links which may have to be "plugged". 2169 - Reset device type flag at 409CH to zero (output to video display), also turns off cassette drive if necessary. CALLs Disk BASIC link at 41BEH prior to return.

2137-2139TABER
GOSUB forward to 2B1BH to evaluate the tab number at the location of the current BASIC program pointer in HL and return with the result in register A.
213A-213B
AND 3FH
The results are in A so mask the tab number in register A so that it doesn't exceed 63.
Difference between M1 and M3 ROMs: This also first appeared in the "new" ROMs of the Model I, as part of an AND 7FH instruction located at 213AH. In the original version the instruction was AND 3FH. The operand of the instruction sets the maximum argument for the TAB function, thus the early TRS-80's could only handle a maximum TAB (63) while the latest Models can go as high as TAB (127).
213C
LD B,A
Load register B with the value of the tab number from register A.
213D-213E
RST 08H ⇒ 29
At this point, we have a TAB(nn, so the next character needs to be a ). Since the character at the location of the current BASIC program pointer in HL must be a ")", call the COMPARE SYMBOL at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL register to the value in the location following the RST 08 call.
  • If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
  • If the two characters do not match, a syntax error message is given and control returns to the Input Phase).
213F
DEC HL
Decrement the value of the current BASIC program pointer in HL so that it points to the (.

To use a ROM call to locate the cursor at position n on the current display line, where n is an integer between 0 and 3FH, inclusive, first load the E register with the value of n and then load the HL register pair with the address of a zero byte in memory. Once that's done CALL 213FH.

  • NOTE 1: The cursor position cannot be moved backward by this procedure. If n is not greater than the current cursor position on the line, no change will occur.
  • NOTE 2: To locate the cursor at a given position on the screen (the function of the PRINT@ command in BASIC), the simplest procedure is to modify the cursor position bytes, which are located at 4020H-4021H. The address contained in these memory cells is that of the position in video memory (3C00H-3FFFH) at which the (abstract) cursor resides. This cursor position controls subsequent printing via the subroutine at 28A7H
  • DISK SYSTEM CAUTION: The subroutine at 213FH has three exits to DISK BASIC, with RAM transfer points at 41BEH, 41C1H, and 41D3H. To use this routine safely, either be certain that DISK BASIC is in place, or have your assembly language program fill locations 41BEH, 41C1H, and 41D3H with RET's (C9H), before calling the routine.

2140
Save the value of the current BASIC program pointer in HL to the stack.
2141-2143
Call the DOS link at 41DCH.
2144-2146
LD A,(409CH)LD A,(PRTFLG)
Load register A with the value of the current output device flag..
  • Note: 409CH holds the current output device flag:
    • -1=cassette,
    • 0=video; or
    • 1=printer.
2147
OR A
Test the value of the current output device flag in register A.
2148-214A
Display a ?FC ERROR message if the current output device is the cassette recorder.
214B-214D
Jump forward a few instructions to 2153H if the current output device is the video display.
214E-2150
LD A,(409BH)LD A,(LPTPOS)
Since we have already jumped away if the current output device is to cassette or screen, if we are here we know that this is to go to the printer, so load register A with the current carriage position.
Note: 409BH holds the printer carriage position.
2151-2152
Jump over the next instruction (which is a video instruction).
2153-2155TTYIST
LD A,(40A6H)LD A,(TTYPOS)
Load register A with the current video line position.
Note: 40A6H holds the current cursor line position.
2156DOSIZT
CPL
When we land here, A holds either the current carriage position (printer) or the current line position (video). Regardless, complement (make negative) that value.
2157
ADD A,E
Add the tab number in register B to the adjusted line position in register A so that A=-current position + tab.
2158-2159
Jump forward a few instructions to 2164H to skip over the actual TAB effectuation routine if the tab number in register B is less than the line position in register A.
215AASPA2
INC A
Bump the number of spaces to be printed in register A.
215BASPAC
LD B,A
Load register B with the number of spaces to be printed in register A.
215C-215D
LD A,20H
Load register A with a space.
215E-2160REPOUT
Send the space in register A to the current output device.
2161
DEC B
Decrement the value of the space counter in register B.
2162-2163
Loop back to 215EH until all of the spaces have been displayed/printed.
2164NOTABR
POP HL
Restore the position in of the current BASIC program pointer (from the stack) into HL.
2165
RST 10H
We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
*2166-2168
Jump back to 2081H to process the rest of the PRINT TAB statement.
Difference between M1 and M3 ROMs: This corrects a jump back into the revised PRINT command routine.

2169 - This routine resets the device type flag at 409CH to zero (output to video display), also turns off cassette drive if necessary. CALLs Disk BASIC link at 41BEH prior to return

2169-216BFINPRT
LD A,(409CH)LD A,(PRTFLG)
If we land here, we need to turn off the cassette and reset the current output device to be video. To do this we first load register A with the current output device flag..
  • Note: 409CH holds the current output device flag:
    • -1=cassette,
    • 0=video; or
    • 1=printer.
216C
OR A
Test the value of the current output device flag in register A. If the M flag is set, A was negative.
216D-216F
If the current output device flag is the cassette recorder, GOSUB to 01F8H to turn it off.
2170
XOR A
Clear Register A (which will set A to 0) and clear the status flags.
2171-2173
LD (409CH),ALD (PRTFLG),A
Save the value in register A (which is 0) as the current value of the output device flag.
  • Note: 409CH holds the current output device flag:
    • -1=cassette,
    • 0=video; or
    • 1=printer.
2174-2176
Call the DOS link at 41BEH.
In NEWDOS 2.1, this initializes the system output device.
2177
RET
Return.

2178-217E - MESSAGE STORAGE LOCATION FOR REDO MESSAGE

2178-217ETRYAGN
"?REDO"
The ?REDO message is stored here.

217F-2285 - LEVEL II BASIC INPUT AND READ ROUTINES

We are here when the data that was typed in or in "DATA" statements is improperly formatted. For "INPUT" we start again. For "READ" we give a syntax error at the data line.

217F-2181TRMNOK
LD A,(40DEH)LD A,(FLGINP)
Load register A with the read flag to help determine if this was READ or INPUT.
Note: 40DEH holds READ flag.
2182
OR A
Check to see if the read flag is set. If it is ZERO then it was INPUT.
2183-2185
If the read flag is set, then we had a READ, go give a ?SN ERROR.
2186-2188
LD A,(40A9H)LD A,(CASFLG)
Now we know the read flag is NOT set, so we need to load register A with the input type flag.
Note: 40A9H holds Cassette input flag.
2189
OR A
Check to see if the cassette recorder is the current input device.
218A-218B
LD E,2AHLD E,ERRFD
Load register E with the ?FD ERROR code.
218C-218E
If the current input device is the cassette recorder, go give a ?FD ERROR.
218F
POP BC
Clean up the stack to get rid of the pointer into the variable list.
2190-2192RDOINP
LD HL,2178H
Load HL with the starting address of the ?REDO message.
2193-2195
We need to display the ?REDO, so we call the WRITE MESSAGE routine at 28A7H.
NOTE:
  • The routine at 28A7 displays the message pointed to by HL on current system output device (usually video).
  • The string to be displayed must be terminated by a byte of machine zeros or a carriage return code 0D.
  • If terminated with a carriage return, control is returned to the caller after taking the DOS exit at 41D0H (JP 5B99H).
2196-2198
LD HL,(40E6H)LD HL,(SAVTXT)
Get the value of the current BASIC program pointer in HL.
Note: 40E6H-40E7H holds Temporary storage location.
2199
RET
Return out of this routine to NEWSTT of the INPUT routine.

219A - INPUT logic

219A-219CINPUT
Check to see if there is an illegal direct in the input statement.
219D
LD A,(HL)
Load register A with the character at the location of the current BASIC program pointer in HL.
219E-21A0
Call the DOS link at 41D6H.
In NEWDOS 2.1 this is called at the beginning of INPUT processing.
21A1-21A2
SUB 23H
Check to see if the character at the location of the current BASIC program pointer in register A is a #.
21A3-21A5
LD (40A9H),ALD (CASFLG),A
Set the current input device flag for the cassette recorder.
Note: 40A9H holds cassette input flag.
21A6
LD A,(HL)
Load register A with the character at the location of the current BASIC program pointer in HL.
21A7-21A8
Jump to 21C9H if there is keyboard input.
21A9-21AB
If we are here, then the input is coming from the cassette, so GOSUB to 0293H to turn on the cassette.
21AC
PUSH HL
Save the current BASIC program pointer in HL to the stack.
21AD-21AE
LD B,FAH
Load register B with the maximum size of the input buffer.
21AF-21B1
LD HL,(40A7H)LD HL,(BUFPNT)
Load HL with the starting address of the input buffer.
Note: 40A7H-40A8H holds the input Buffer pointer.
21B2-21B4FILBUF
Calls the READ ONE BYTE FROM CASSETTE routine at 0235H (which reads one byte from the cassette drive specified in register A, and returns the byte in register A).
21B5
LD (HL),A
Save the byte read from the cassette recorder in register A at the location of the input buffer pointer in HL.
21B6
INC HL
Bump the value of the input buffer pointer in HL.
21B7-21B8
CP 0DH
Check to see if the character read from the cassette recorder in register A is a carriage return.

Notes:

  • 0DH is a ENTER in ASCII
  • A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
21B9-21BA
Jump out of this routine if the character read from the cassette recorder in register A is a carriage return.
21BB-21BC
Loop back to 21B2H until the input buffer is full.
21BDENDREC
DEC HL
Decrement the value of the input buffer pointer in HL to put in the terminator.
21BE-21BF
LD (HL),00H
Save a zero at the location of the input buffer pointer in HL.
21C0-21C2
GOSUB to 01F8H to put a 00H at the end of the tape and turn the cassette recorder off.
21C3-21C5
LD HL,(40A7H)LD HL,(BUFPNT)
Load HL with the starting address of the input buffer.
Note: 40A7H-40A8H holds the input Buffer pointer.
21C6
DEC HL
Decrement the value of the input buffer pointer in HL.
21C7-21C8
Jump to 21EBH to store a comma there so we can use the READ processing.
21C9-21CBINTCAS
LD BC,21DBHLD BC,NOTQTI
Load BC with a return address of 21DBH.
21CC
PUSH BC
Save the value of the return address in BC to the stack.
21CD-21CEQTINP
CP 22H
Check to see if the character at the location of the current BASIC program pointer in register A is a quote.

Notes:

  • 22H is a " in ASCII
  • A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
21CF
Return to 21DBH if the character at the location of the current BASIC program pointer in register A isn't a quote.
21D0-21D2
Go set up pointers for the prompting message in the temporary string work area.
21D3-21D4
RST 08H ⇒ 3B
Since the character at the location of the current BASIC program pointer in HL must be a ";", call the COMPARE SYMBOL routine at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL register to the value in the location following the RST 08 call.
  • If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
  • If the two characters do not match, a syntax error message is given and control returns to the Input Phase).
21D5
PUSH HL
Save the value of the current BASIC program pointer in HL to the stack.
21D6-21D8
Go display the prompting message.
21D9
POP HL
Restore the code string address (from the stack) into HL.
21DA
Return to 21DBH.
21DBNOTQTI
PUSH HL
Save the value of the current BASIC program pointer in HL to the stack.
21DC-21DEGETAGN
Print the ? prompt and get the input from the keyboard.
21DF
POP BC
Get the value of the current BASIC program pointer from the stack and put it in BC.
21E0-21E2
Jump back to 1DBEH if the BREAK key was pressed.
21E3
INC HL
Bump the value of the input buffer pointer in HL.
21E4
LD A,(HL)
Load register A with the character at the location of the input buffer pointer in HL.
21E5
OR A
Test the value of the character at the location of the input buffer pointer in register A.
21E6
DEC HL
Decrement the value of the input buffer pointer in HL.
21E7
PUSH BC
Save the value of the current BASIC program pointer in BC to the stack.
21E8-21EA
Jump if the character at the location of the input buffer pointer in register A is an end of the input character.
21EB-21ECINPCN3
LD (HL),2CH
Save a comma at the location of the current input buffer pointer in HL.
21ED-21EE
Jump to 21F4H (which address uses a Z-80 trick).

21EF - "READ" logic

21EFREAD
PUSH HL
Save the current BASIC program pointer in HL.
21F0-21F2
LD HL,(40FFH)LD HL,(DATPTR)
Load HL with the location of the last DATA statement read.
Note: 40FFH-4100H holds READ pointer.
21F3-21F4
OR AFH
Z-80 Trick to block out the next opcode if passing through. Otherwise, set register A to a non-zero value if entered from the READ routine and zero if entered from the INPUT routine.
21F4INPCON
XOR A
Set the flag that this is an INPUT.
21F5-21F7
LD (40DEH),ALD (FLGINP),A
Save the value of the input type flag in register A.
Note: 40DEH holds READ flag.

N THE PROCESSING OF DATA AND READ STATEMENTS: ONE POINTER POINTS TO THE DATA (IE THE NUMBERS BEING FETCHED) AND ANOTHER POINTS TO THE LIST OF VARIABLES. THE POINTER INTO THE DATA ALWAYS STARTS POINTING TO A TERMINATOR -- A , : OR END-OF-LINE

21F8
EX (SP),HL
Exchange the start of the input pointer in HL with the current BASIC program pointer to the stack.
21F9-21FA
Skip over the next instruction.
21FB-21FCLOPDT2
RST 08H ⇒ 2C
Since the character at the location of the current BASIC program pointer in HL must be a ,, call the COMPARE SYMBOL at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL register to the value in the location following the RST 08 call.
  • If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
  • If the two characters do not match, a syntax error message is given and control returns to the Input Phase).
21FD-21FFLOPDAT
Call the FIND ADDRESS OF VARIABLE routine at 260DH which searches the Variable List Table for a variable name which matches the name in the string pointed to in HL, and return the address of that variable in DE (and if there is no variable, it creates it, zeroes it, and returns THAT location).
2200
EX (SP),HL
Exchange the value of the current BASIC program pointer in HL with the start of the input buffer pointer to the stack.

NOTE AT THIS POINT WE HAVE A VARIABLE WHICH WANTS DATA AND SO WE MUST GET DATA OR COMPLAIN

2201
PUSH DE
Save the variable's address in DE to the stack.
2202
LD A,(HL)
Load register A with the character at the location of the input buffer pointer in HL.
2203-2204
CP 2CH
Check to see if the character at the location of the input buffer pointer register A is a ,.
NOTE: A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
2205-2206
Jump to 222DH if the character at the location of the input buffer pointer in register A is a ,.
2207-2209
LD A,(40DEH)LD A,(FLGINP)
Load register A with the input type flag.
Note: 40DEH holds READ flag.
220A
OR A
Check for READ or INPUT.
220B-220D
Jump to 2296H if the input type flag in register A indicates READ.
220E-2210
LD A,(40A9H)LD A,(CASFLG)
Load register A with the value of the cassette input flag.
Note: 40A9H holds Cassette input flag.
2211
OR A
Check to see if the input is from the cassette recorder.
2212-2213
LD E,06H
Load register E with an ?OD ERROR code.
2214-2216
Go to the Level II BASIC error routine and display an ?OD ERROR message if the input is from the cassette recorder.
2217-2218
LD A,3FH
Load register A with a "?".
2219-221B
GOSUB to 032AH which is a general purpose output routine that outputs a byte from the A register to video, tape or printer (based on what is in 409CH).
221C-221E
Go get the keyboard input.
221F
POP DE
Get the address of the variable to be set from the stack and put it in DE.
2220
POP BC
Get the value of the current BASIC program pointer from the stack and put it in BC.
2221-2223
Jump to 1DBEH if the BREAK key was pressed.
2224
INC HL
Bump the value of the input buffer pointer in HL.
2225
LD A,(HL)
Load register A with the character at the location of the input buffer pointer in HL.
2226
OR A
Check to see if the character at the location of the input buffer pointer in register A is an end of the input character.
2227
DEC HL
Decrement the value of the input buffer pointer in HL.
2228
PUSH BC
Save the value of the current BASIC program pointer in BC to the stack.
2229-222B
Jump if the character at the location of the input buffer pointer in register A is an end of the input character.
222C
PUSH DE
Save the variable's address in DE to the stack.
222D-222FDATBK
Call the DOS link at 41DCH.
In NEWDOS 2.1, this is called during READ processing when a variable has been read.
2230
RST 20H
We need to check the value of the current number type flag, so we call the TEST DATA MODE routine at RST 20H.
NOTE: The RST 20H routine determines the type of the current value in REG 1 and returns a combination of STATUS flags and unique numeric values in the A Register according to the data mode flag (40AFH).

The results are returned as follows:
If the Variable Type is ...and the Flags
are set ...		... then Register
A will be set ...
IntegerNZ/C/M/E-1
StringZ/C/P/E0
Single PrecisionNZ/C/P/O1
Double PrecisionNZ/NC/P/E5
2231
PUSH AF
Save the number type of the variable to the stack.
2232-2233
If that test shows we do NOT have a STRING, jump to 224DH.
2234
RST 10H
We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2235
LD D,A
Load register D with the character at the location of the input buffer pointer in register A.
2236
LD B,A
Load register B with the character at the location of the input buffer pointer in register A.
2237-2238
CP 22H
Check to see if the character at the location of the input buffer pointer in register A is a quote.
NOTE: A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
2230-223A
Jump to 2240H if the character at the location of the input buffer pointer in register A is a quote.
223B-223C
LD D,3AH
Load D with the character :.
223D-223E
LD B,2CH
Load register B with the character , (the scan character).
223F
DEC HL
Decrement the value of the input buffer pointer in HL.
2240-2242NOWGET
Go set up the pointers for the temporary string work area.
2243DOASIG
POP AF
Get the number type for the variable from the stack and put it in register A.
2244
EX DE,HL
Load DE with the value of the input buffer pointer in HL.
2245-2247
LD HL,225AH
Load HL with the value of the return address.
2248
EX (SP),HL
Exchange the value of the return address in HL with the value of the current BASIC program pointer to the stack.
2249
PUSH DE
Save the value of the input buffer pointer in DE to the stack.
224A-224C
Go set the variable to the value of the string.
224DNUMINS
RST 10H
We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
224E
POP AF
Load register A with the number type for the variable to be set.
224F
PUSH AF
Save the value in AF to the stack.
2250-2252
LD BC,2243HLD BC,DOASIG
Load BC with the value of the return address.
2253
PUSH BC
Save the return address in BC to the stack.
2254-2256
If the current number type is integer or single precision, call the ASCII TO BINARY routine at 0E6C (which converts the ASCII string pointed to by HL to binary with the result in REG 1 and the mode flag will have changed).
2257-2259
If the current number type is double precision, jump to the ASCII TO DOUBLE routine at 0E65H.
  • NOTE: 0E65H converts the ASCII string pointed to by HL to its double precision equivalent; with output left in REG 1).
225ASTRDN2
DEC HL
Decrement the value of the input buffer pointer in HL.
225B
RST 10H
We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
225C-225D
Jump to 2263H if the character at the location of the input buffer pointer in HL is an end of the input character.
225E-225F
CP 2CH
Check to see if the character at the location of the input buffer pointer in register A is a comma.
NOTE: A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
2260-2262
Jump to 217FH if the character at the location of the input buffer pointer in register A isn't a comma.
2263TRMOK
EX (SP),HL
Exchange the value of the input buffer pointer in HL with the value of the current BASIC program pointer to the stack.
2264
DEC HL
Decrement the value of the current BASIC program pointer in HL.
2265
RST 10H
We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2266-2268
Go examine the next variable if the character at the location of the current BASIC program pointer in HL isn't an end of the BASIC statement character.
2269
POP DE
Clean up the stack.
226A
NOP
226B
NOP
226C
NOP
226D
NOP
226E
NOP

226F-2285 - For ROM v1.2

226F-2271
LD A,(40DEH)LD A,(FLGINP)
Load register A with the value of the input type flag.
Note: 40DEH holds READ flag.
2272
OR A
Check to see if the input type is READ or INPUT.
2273
EX DE,HL
Load DE with the value of the current BASIC program pointer in HL.
2274-2276
Jump if the input type flag is set for READ .
2277
PUSH DE
Save the current BASIC program pointer in DE to the stack.
2278-227A
Call the DOS link at 41DFH.
In NEWDOS 2.1 this is called at the end of READ processing.
227B
OR (HL)
Check to see if this is the end of the input.
227C-227E
LD HL,2286HLD H,EXIGNT
Load HL with the starting address of the ?EXTRA IGNORED message.
227F-2281
We need to display the ?EXTRA IGNORED message, so we call the WRITE MESSAGE routine at 28A7H.
NOTE:
  • The routine at 28A7 displays the message pointed to by HL on current system output device (usually video).
  • The string to be displayed must be terminated by a byte of machine zeros or a carriage return code 0D.
  • If terminated with a carriage return, control is returned to the caller after taking the DOS exit at 41D0H (JP 5B99H).
2282FINPRG
POP HL
Get the value of the current BASIC program pointer from the stack and put it in HL.
2283-2285
Go turn off the cassette recorder and return to the BASIC interpreter.

2286-2295 - MESSAGE STORAGE LOCATION

2286-2295EXIGNT
"?Extra ignored"
The EXTRA IGNORED message is stored here.

2296-22B5 - FIND THE NEXT DATA STATEMENT ROUTINE

SUBROUTINE TO FIND DATA. IN THE 4K "DATA" MUST BE AT THE START OF THE LINE SO THE SEARCH IS MADE USING THE LINKS AT THE START OF EACH LINE. IN THE 8K AND EXTENDED THE SEARCH IS MADE BY USING THE EXECUTION CODE FOR DATA TO SKIP OVER STATEMENTS. THE START WORD OF EACH STATEMENT IS COMPARED WITH $DATA. EACH NEW LINE NUMBER IS STORED IN DATLIN SO THAT IF AN ERROR OCCURS WHILE READING DATA THE ERROR MESSAGE WILL GIVE THE LINE NUMBER OF THE ILL-FORMATTED DATA

2296-2298DATLOP
Go find the next DATA statement.
2299DATFND
OR A
Check to see if this is the end of the BASIC line.
229A-229B
Jump to 22AEH if the BASIC statement is terminated with a :.
229C
INC HL
Bump the value of the current BASIC program pointer in HL.
229D
LD A,(HL)
Load register A with the LSB of the line address at the location of the current BASIC program pointer in HL.
229E
INC HL
Bump the value of the current BASIC program pointer in HL.
229F
OR (HL)
Combine the MSB of the line address at the location of the current BASIC program in HL with the LSB of the line address in register A.
22A0-22A1
LD E,06H
Load register E with an ?OD ERROR code.
22A2-22A4
Go to the Level II BASIC error routine and display an OD ERROR message if this is the end of the BASIC program.
22A5
INC HL
Bump the value of the current BASIC program pointer in HL.
22A6
LD E,(HL)
Load register E with the LSB of the BASIC line number at the location of the current BASIC program pointer in HL.
22A7
INC HL
Bump the value of the current BASIC program pointer in HL.
22A8
LD D,(HL)
Load register D with the MSB of the BASIC line number at the location of the current BASIC program pointer in HL.
22A9
EX DE,HL
Exchange the value of the current BASIC program pointer in HL with the value of the BASIC line number in DE.
22AA-22AC
LD (40DAH),HLLD (DATLIN),HL
Save the BASIC line number in HL.
Note: 40DAH-40DBH holds DATA line number.
22AD
EX DE,HL
Exchange the value of the current BASIC program pointer in DE with the value of the BASIC line number in HL.
22AENOWLIN
RST 10H
We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
22AF-22B0
CP 88H
Check to see if the character at the location of the current BASIC program pointer in register A is a DATA token.
NOTE: A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
22B1-22B2
Jump to 2296H (=find the next DATA statement routine) if the character at the location of the current BASIC program pointer in register A isn't a DATA token.
22B3-22B5
Now we know that the current BASIC program pointer is pointing to a DATA token, so jump to 222DH.

22B6-2336 - LEVEL II BASIC NEXT ROUTINE

A "FOR" ENTRY ON THE STACK HAS THE FOLLOWING FORMAT:

  • LOW ADDRESS
    • TOKEN ($FOR IN HIGH BYTE) 1 BYTES
    • A POINTER TO THE LOOP VARIABLE 2 BYTES
    • A BYTE REFLECTING THE SIGN OF THE INCREMENT 1 BYTE
    • THE STEP 4 BYTES
    • THE UPPER VALUE 4 BYTES
    • THE LINE # OF THE "FOR" STATEMENT 2 BYTES
    • A TEXT POINTER INTO THE "FOR" STATEMENT 2 BYTES
  • HIGH ADDRESS
22B6-22B8NEXT
LD DE,0000H
Load DE with the default variable address.
22B9-22BBNEXTC
To see if there is a variable which follows the NEXT token, call the FIND ADDRESS OF VARIABLE routine at 260DH which searches the Variable List Table for a variable name which matches the name in the string pointed to in HL, and return the address of that variable in DE (and if there is no variable, it creates it, zeroes it, and returns THAT location).
22BC-22BE
LD (40DFH),HLLD (TEMP),HL
Save the value of the current BASIC program pointer (contained in 40DFH) in HL.
Note: 40DFH-40E0H holds Used by DOS.
22BF-22C1
Go search the stack for the appropriate FOR push.
22C2-22C4
Display a NF ERROR message if the appropriate FOR push wasn't found.
22C5
LD SP,HL
Load the stack pointer with the value of the memory pointer in HL.
22C6-22C8
LD (40E8H),HLLD (SAVSTK),HL
Save the value in HL.
Note: 40E8H-40E9H holds Stack pointer pointer.
22C9
PUSH DE
Save the variable's address in DE to the stack.
22CA
LD A,(HL)
Load register A with the value of the sign for the STEP value.
22CB
INC HL
Bump the value of the memory pointer in HL.
22CC
PUSH AF
Save the value of the sign for the STEP value in register A to the stack.
22CD
PUSH DE
Save the variable's address in DE to the stack.
22CE
LD A,(HL)
Load register A with the number type flag for the STEP value.
22CF
INC HL
Bump the value of the memory pointer in HL.
22D0
OR A
Check the value of the number type flag for the STEP flag in register A.
22D1-22D3
Jump to 22EAH if the STEP value is an integer.
22D4-22D6
CALL 09B1HCALL MOVFM (which moves a SINGLE PRECISION number pointed to by HL to REG 1).
22D7
EX (SP),HL
Exchange the value of the variable's address to the stack with the value of the memory pointer in HL.
22D8
PUSH HL
Save the value of the variable's address in HL to the stack.
22D9-22DB
Go add the sin le precision value at the location of the memory pomter in HL to the single precision STEP value in register pairs BC and DE. Return with the result in REG 1.
22DC
POP HL
Get the value of the variable's address from the stack and put it in HL.
22DD-22DF
Go move the single precision result from REG 1 to the variable's address in HL.
22E0
POP HL
Get the value of the memory pointer from the stack and put it in HL.
22E1-22E3
CALL 09C2HCALL MOVRM (which loads a SINGLE PRECISION value pointed to by HL into register pairs BC and DE).
22E4
PUSH HL
Save the value of the memory pointer in HL to the stack.
22E5-22E7
Call the SINGLE PRECISION COMPARISON routine at 0A0CH.

NOTE: The routine at 0A0CH algebraically compares the single precision value in BC/DE to the single precision value REG 1.
The results are stored in A as follows:
  • A=0 if REG 1 = BCDE
  • A=1 if REG 1>BCDE; and
  • A=FFH if REG 1<BCDE.
22E8-22E9
Jump forward to to 2313H.
22EAINTNXT
INC HL
We need to backspace the stack by 4 bytes to skip over the area which would hold the single precision TO value to do this we have to bump the value of the memory pointer in HL 4 times.
22EB
INC HL
Bump the value of the memory pointer in HL.
22EC
INC HL
Bump the value of the memory pointer in HL.
22ED
INC HL
Bump the value of the memory pointer in HL.
22EE
LD C,(HL)
Load register C with the LSB of the STEP value (held at the location of the memory pointer in HL).
22EF
INC HL
Bump the value of the memory pointer in HL to be the MSB of the STEP value.
22F0
LD B,(HL)
Load register B with the MSB of the STEP value at the location of the memory pointer in HL.
22F1
INC HL
Bump the value of the memory pointer in HL so that it is the stack address of the TO limit.
22F2
EX (SP),HL
Exchange HL and the value of the stack pointer so that HL will have the address of the index and the value at the stack pointer will have the ending address of the TO limit.
22F3
LD E,(HL)
Load register E with the LSB of the index.
22F4
INC HL
Bump the value of the memory pointer in HL to point to the MSB of the index.
22F5
LD D,(HL)
Load register D with the MSB of the index.
22F6
PUSH HL
Save the value of the memory pointer in HL to the stack.
22F7
LD L,C
Load register L with the LSB of the STEP value in register C.
22F8
LD H,B
Load register H with the MSB of the STEP value in register B.
22F9-22FB
With the STEP value in HL, call the INTEGER ADD routine at 0BD2H (which adds the integer value in DE to the integer in HL. The sum is left in HL and the orginal contents of DE are preserved. If overflow occurs (sum exceeds 2**15), both values are converted to single precision and then added. The result would be left in REG 1 and the mode flag would be updated).
22FC-22FE
LD A,(40AFH)LD A,(VALTYP)
Load register A with the current value of the data type flag.
Note: 40AFH holds Current number type flag.
22FF
CP 04H
Check to see if the current value in REG 1 is single precision.
NOTE: A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
2301-2303
Show an ?OV ERROR message if the current value in REG 1 is single precision.
2304
EX DE,HL
Load DE with the index as an integer (from HL).
2305
POP HL
Restore the address of the index in the variable area to HL.
2306
LD (HL),D
Save the MSB of the result in register D at the location of the memory pointer in HL.
2307
DEC HL
Decrement the value of the memory pointer in reg? ister pair HL.
2308
LD (HL),E
Save the LSB of the result in register E at the location of the memory pointer in HL.
2309
POP HL
Restore the address of the TO value in the FOR statement to HL.
230A
PUSH DE
Save the index in DE to the stack.
230B
LD E,(HL)
Load register E with the LSB of the TO value at the location of the memory pointer in HL.
230C
INC HL
Bump the value of the memory pointer in HL to point to the MSB of the TO value.
230D
LD D,(HL)
Load register D with the MSB of the TO value at the location of the memory pointer in HL.
230E
INC HL
Bump the value of the memory pointer in HL so now it points to the line number.
230F
EX (SP),HL
Swap the TO value at the memory location pointed to by the stack with the address of the binary line number for the FOR statement (now in HL).
2310-2312
We need to compare the new index to the limit so we call the INTEGER COMPARISON routine at 0A39H (which algebraically compares two integer values in DE and HL. The contents of DE and HL are left intact. The result of the comparison is left in the A register and status register as:
If DE > HL then A will be -1;
If DE < HL then A will b +1; and
If DE = HL then A will be 0.
2313FINNXT
POP HL
Restore the address of the binary line number of the FOR statement back into HL.
2314
POP BC
Get the value of the sign from the stack and put it in BC.
2315
SUB B
We need to see if the sign is the sign we expected so we subtract the value of the sign in register B from the value in register A.
2316-2318
CALL 09C2HCALL MOVRM (which loads a SINGLE PRECISION value pointed to by HL into register pairs BC and DE).
2319-231A
Jump to 2324H if the index does not equal the TO limit (meaning the FOR ... NEXT loop has not been completed).
231B
EX DE,HL
Load HL with the BASIC line number of the FOR statement in DE.
231C-231E
LD (40A2H),HLLD (CURLIN),HL
Save the BASIC line number in HL as the current BASIC line number.
NOTE:40A2H-40A3H holds the current BASIC line number.
231F
LD L,C
Load register L with the LSB of the current BASIC program pointer in register C.
2320
LD H,B
Load register H with the MSB of the current BASIC program pointer in register B.
2321-2323
Jump to 1D1AH to continue execution and restore the FOR token and GAP for FOR
2324LOOPDN
LD SP,HL
Restore the stack pointer - Start of expression evaluation
2325-2327
LD (40E8H),HLLD (SAVSTK),HL
Load HL with the value of the current BASIC program pointer.
Note: 40E8H-40E9H holds Stack pointer pointer.
2328-232A
LD HL,(40DFH)LD HL,(TEMP)
Save the value of the current BASIC program pointer in HL.
Note: 40DFH-40E0H holds Used by DOS.
232B
LD A,(HL)
Load register A with the next token (i.e., the character at the location of the current BASIC program pointer in HL).
232C-232D
CP 2CH
Check to see if the character at the location of the current BASIC program pointer in register A is a ,.
NOTE: A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
232E-2330
Jump back to 1D1EH if the character at the location of the current BASIC program pointer in register A isn't a ,.
2331
RST 10H
We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2332-2334
GOSUB to 22B9H to process NEXT.

2335-27C8 - EVALUATE EXPRESSION

This routine evaluates a BASIC expression pointed to by the HL and stores the result in the ACC. The expression must be terminated with zero byte, comma, right bracket or colon. After execution, HL will point to the delimiter and, in the case of string expressions, the ACC will contain the address of the first of three bytes that contain string length and string address. Note that the stack is used frequently and the machine should be formatted for RUN mode in order to use this routine.

2335FRMPRN
RST 08H ⇒ 28
Since the character at the location of the current BASIC program pointer in HL must be a (, call the COMPARE SYMBOL routine at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL register to the value in the location following the RST 08 call.
  • If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
  • If the two characters do not match, a syntax error message is given and control returns to the Input Phase).
2337FRMEVL
DEC HL
Decrement the value of the current BASIC program pointer in HL.
2338-2339FRMCHK
LD D,00H
Load register D with zero.
233ALPOPER
PUSH DE
Save the value in DE to the stack.
233B-233C
LD C,01H
Load register C with the number of bytes of memory required.
233D-233F
Go do a memory check.
2340-2342
Go get the value of the next part of the expression at the location of the current BASIC program pointer in HL.
2343-2345
LD (40F3H),HLLD (TEMP2),HL
Save the value of the current BASIC program pointer (i.e., the next token) in HL.
Note: 40F3H-40F4H holds temporary storage location.
2346-2348RETAOP
LD HL,(40F3H)LD HL,(TEMP2)
Load HL with the value of the current BASIC program pointer.
Note: 40F3H-40F4H holds temporary storage location.
2349TSTOP
POP BC
Get the last precedence value from the stack and put it in BC.
234ANOTSTV
LD A,(HL)
Load register A with the character at the location of the current BASIC program pointer in HL.
234B-234C
LD D,00H
Load register D with zero.
234D-234ELOPREL
SUB D4HSUB GREATK
Check to see if the character at the location of the current BASIC program pointer in register A is an arithmetic or logical token (by subtracting 212 from it).
234F-2350
Jump to 2364H if the character at the location of the current BASIC program pointer in register A is +, -, *, /, ?, AND or OR.
2351-2352NMREL
CP 03HCP LESSTK-GREATK+1
Check to see if the character at the location of the current BASIC program pointer in register A is a >, =, or <.
NOTE: A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
2353-2354
Jump if the character at the location of the current BASIC program pointer in register A isn't a >, =, or <.
2355-2356
CP 01H
Set the Carry flag if >. Then test for <= or >=.
2357
RLA
Adjust the value in register A to give > as 1, = as 2, or < as 4.
2358
XOR D
Combine the current value in register A with the value of the last token examined to see if this is a legal combination of <= or => or illegal combination of <<, ==, or >>.
2359
CP D
Check for an illegal combination of operators.
235A
LD D,A
Load register D with the value in register A.
235B-235D
Display a ?SN ERROR if this is an illegal combination of operators.
235E-2360
LD (40D8H),HLLD (TEMP3),HL
Save the address of the >, =, or < token (held in HL) to 40D8H.
Note: 40D8H-40D9H holds Temporary storage location.
2361
RST 10H
We need the next token so call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2362-2363
Jump back to 234DH.
2364ENDREL
LD A,D
Load register A with the value of the operator in register D.
2365
OR A
Test the value of the operator in register A.
2366-2368
Jump if the operator in register A is >, =, or <.
2369
LD A,(HL)
Load register A with the character at the location of the current BASIC program pointer in HL.
236A-236C
LD (40D8H),HLLD (TEMP3),HL
Save the address of the current BASIC program pointer in HL (which is an arithmetic operator) to 40D8H.
Note: 40D8H-40D9H holds Temporary storage location.
236D-236E
SUB 0CDH
Check to see if the operator at the location of the current BASIC program pointer in register A is an arithmetic token.
236F
RET C
Return if the character at the location of the current BASIC program pointer in register A isn't an arithmetic token.
2370-2371
CP 07H
Check to see if the character at the location of the current BASIC program pointer in register A is a + to OR token.
2372
RET NC
Return if the character at the location of the current BASIC program pointer in register A isn't a + to OR token.
2373
LD E,A
Load register E with the operator value in register A (which would be between 0 and 7).
E   Token
0   +
1   -
2   *
3   /
4   @@
5   AND
6   OR
2374-2376
LD A,(40AFH)LD A,(VALTYP)
Load register A with the current value of the number type flag.
Note: 40AFH holds Current number type flag.

2377 - PRINT@ logic.

2377-2378
SUB 03H
Adjust the value of the number type flag to get a -1 if integer, 0 for a string, 1 for single precision, and 5 for double precision.
2379
OR E
Combine the operator value in register E with the adjusted number type flag in register A.
237A-237C
Jump down to 298FH if the combination of the adjusted number type flag in register A and the operator value in register E indicates string addition.
237D-237F
LD HL,189AHLD HL,OPTAB
Load HL with the starting address of the table of precedence operator values.
2380
ADD HL,DE
Add the value of the operator in DE to the table of precedence values pointer in HL.
2381
LD A,B
Load register A with the precedence value for the last operator in register B.
2382
LD D,(HL)
Load register D with the precedence value for the current operator.
2383
CP D
Compare the precedence value for the current operator in register D with the precedence value for the last operator in register A.
2384
RET NC
Return out of this routine if the precedence value for the current operator in register D is greater than the precedence value for the last operator in register A.
2385
PUSH BC
Save the precedence value and the token for the last operator in BC to the stack.
2386-2388
LD BC,2346HLD B,RETAOP
Load BC with the return address in case there is a break in precedence.
2389
PUSH BC
Save the return address in BC to the stack.
238A
LD A,D
Load register A with the precedence value for the current operator in register D.
238B-238C
CP 7FH
Check to see if the precedence value for the current operator in register A indicates an exponential operator.
238D-238F
Jump down to 23D4H if the precedence value for the current operator in register A indicates an exponential operator.
2390-2391
CP 51H
Check to see if the precedence value for the current operator in register A indicates a logical operator.
2392-2394
Jump if the precedence value for the current operator in register A indicates a logical operator.

THIS CODE PUSHES THE CURRENT VALUE IN THE FAC ONTO THE STACK, EXCEPT IN THE CASE OF STRINGS IN WHICH IT CALLS TYPE MISMATCH ERROR. [D] AND [E] ARE PRESERVED. THIS CODE IS ALSO USED BY USER-DEFINED FUNCTION VALUE SAVING, WHICH ENTERS AT PUSVAL WITH CARRY SET.

2395-2397NUMREL
LD HL,4121HLD HL,FACLO
Load HL with the address of REG 1.
2398
OR A
Clear the flags.
2399-239BPUSVAL
LD A,(40AFH)LD A,(VALTYP)
Load register A with the current value of the number type flag.
Note: 40AFH holds Current number type flag.
239C
DEC A
Adjust the current number type flag in register A.
239D
DEC A
Adjust the current number type flag in register A.
239E
DEC A
Adjust the current number type flag in register A. Now A will be -1=Integer, 0=String, 1=Single Precision, 5=Double Precision
239F-23A1
Display a ?TM ERROR if the current value in REG 1 is a string.
23A2
LD C,(HL)
Get the value at the location of the memory pointer in HL and put it in register C.
23A3
INC HL
Bump the value of the memory pointer in HL.
23A4
LD B,(HL)
Load register B with the value at the location of the memory pointer in HL.
23A5
PUSH BC
Save the value in BC to the stack.
23A6-23A8
Jump down to 23C5H if the current number type is an integer.
23A9
INC HL
It's not an integer, so lets get the rest of the value by bumping the value of the memory pointer in HL.
23AA
LD C,(HL)
Load register C with the value at the location of the memory pointer in HL.
23AB
INC HL
Bump the value of the memory pointer in HL.
23AC
LD B,(HL)
Load register B with the value at the location of the memory pointer in HL.
23AD
PUSH BC
Save the value in BC (the rest of the digit) to the stack.
23AE
PUSH AF
Save the value in AF (the type - 3) to the stack.
23AF
OR A
Reset the status flags so that we can test if the current number type is double precision.
23B0-23B2
Jump down to 23C4H if the current number type is single precision.
23B3
POP AF
Clear the stack.
23B4
INC HL
Bump the value of the memory pointer in HL.
23B5-23B6
Skip the next instruction if the current number type is single precision.
23B7-23B9
LD HL,411DHLD HL,DFACLO
Reset HL to start of REG 1.
Note: 411DH-4124H holds REG l.
23BAPUSDVR
LD C,(HL)
Load register C with the rest of the double precision value (held at the location of the memory pointer in HL).
23BB
INC HL
Bump the value of the memory pointer in HL.
23BC
LD B,(HL)
Load register B with the next digit LSB (at the location of the memory pointer in HL).
23BD
INC HL
Bump the value of the memory pointer in HL to the next digit.
23BE
PUSH BC
Save the LSB/NMSB of the double precision value (held in BC) to the stack.
23BF
LD C,(HL)
Load register C with the value at the location of the memory pointer in HL.
23C0
INC HL
Bump the value of the memory pointer in HL.
23C1
LD B,(HL)
Load register B with the value at the location of the memory pointer in HL.
23C2
PUSH BC
Save the value in BC to the stack.
23C3
LD B,0F1H
06 F1
Z-80 Trick to nullify the next opcode if passing through.
23C4VPSHD1
POP AF
Clear the type -3 and the status push.
23C5-23C6VPUSHD
ADD A,03H
Adjust the number type in register A up 3.
23C7
LD C,E
Load register C with the value of the current operator token in register E (0-7).
23C8
LD B,A
Load register B with the number type flag in register A.
23C9
PUSH BC
Save the value in BC to the stack.
23CA-23CC
LD BC,2406HLD BC,APPLOP
Load BC with the return address of 2406H.
23CDFINTMP
PUSH BC
Save the return address in BC to the stack.
23CE-23D0
LD HL,(40D8H)LD HL,(TEMP3)
Load HL with the value of the current BASIC program pointer.
Note: 40D8H-40D9H holds Temporary storage location.
23D1-23D3
Jump back to 233AH.

FOR EXPONENTIATION WE WANT TO FORCE THE CURRENT VALUE IN THE FAC TO BE SINGLE PRECISION. WHEN APPLICATION TIME COMES WE FORCE THE RIGHT HAND OPERAND TO SINGLE PRECISION AS WELL

23D4-23D6EXPSTK
Call the CONVERT TO SINGLE PRECISION routine at 0AB1H (which converts the contents of REG 1 from integer or double precision into single precision).
23D7-23D9
Call 09A4 which moves the SINGLE PRECISION value in REG 1 to the stack (stored in LSB/MSB/Exponent order).
23DA-23DC
LD BC,13F2HLD B,FPWRQ
Load BC with the address of the exponential X^Y routine at 13F2H.
23DD-23DE
LD D,7FH
Load register D with the precedence value for an exponential operator.
23DF-23E0
Jump back to 23CDH to continue expression evaluation.

FOR "AND" AND "OR" AND "\" AND "MOD" WE WANT TO FORCE THE CURRENT VALUE IN THE FAC TO BE AN INTEGER, AND AT APPLICATION TIME FORCE THE RIGHT HAND OPERAND TO BE AN INTEGER

23E1ANDORD
PUSH DE
Save the precedence value and the operator token in DE to the stack.
23E2-23E4
Call the CONVERT TO INTEGER routine at 0A7FH (where the contents of REG 1 are converted from single or double precision to integer and deposited into HL).
23E5
POP DE
Get the precedence value and the operator token from the stack and put it in DE.
23E6
PUSH HL
Save the integer value in HL to the stack.
23E7-23E9
LD BC,25E9HLD BC,DANDOR
Load BC with a return address of 25E9H.
23EA-23EB
Jump back to 23CDH to continue the syntax analysis.

HERE TO BUILD AN ENTRY FOR A RELATIONAL OPERATOR STRINGS ARE TREATED SPECIALLY. NUMERIC COMPARES ARE DIFFERENT FROM MOST OPERATOR ENTRIES ONLY IN THE FACT THAT AT THE BOTTOM INSTEAD OF HAVING RETAOP, DOCMP AND THE RELATIONAL BITS ARE STORED. STRINGS HAVE STRCMP,THE POINTER AT THE STRING DESCRIPTOR, DOCMP AND THE RELATIONAL BITS. ;

23ECFINREL
LD A,B
Load register A with the precedence value for the last operator in register B.
23ED-23EE
CP 64H
Check to see if the last operator was a logical operator.
23EF
RET NC
Return out of this routine if the last operator was a logical operator.
23F0
PUSH BC
Save the precedence value and the operator token for the last operator in BC to the stack.
23F1
PUSH DE
Save the precedence value and the token for the current operator from DE (either a 6, 5, or 3) to the stack.
23F2-23F4
LD DE,6404HLD DE,0+256*100+OPCNT
Load DE with the precedence value and the token for the new operator.
23F5-23F7
LD HL,25B8HLD HL,DOCMP
Load HL with the address of the routine to compare logical quantities ...
23F8
PUSH HL
and push it to the stack.
23F9
RST 20H
We need to check the value of the current number type flag, so we call the TEST DATA MODE routine at RST 20H.
NOTE: The RST 20H routine determines the type of the current value in REG 1 and returns a combination of STATUS flags and unique numeric values in the A Register according to the data mode flag (40AFH).

The results are returned as follows:
If the Variable Type is ...and the Flags
are set ...		... then Register
A will be set ...
IntegerNZ/C/M/E-1
StringZ/C/P/E0
Single PrecisionNZ/C/P/O1
Double PrecisionNZ/NC/P/E5
23FA-23FC
If that test shows we do NOT have a STRING, jump back to 2395H.
23FD-23FF
LD HL,(4121H)LD HL,(FACLO)
Load HL with the string address held at the memory location pointed to by REG 1.
2400
PUSH HL
Save the string's address in HL to the stack.
2401-2303
LD BC,258CHLD BC,STRCMP
Load BC with the address of the string comparison routine.
2404-2405
Jump back to 23CDH.

APPLOP IS RETURNED TO WHEN IT IS TIME TO APPLY AN ARITHMETIC OR NUMERIC COMPARISON OPERATION. THE STACK HAS A DOUBLE BYTE ENTRY WITH THE OPERATOR NUMBER AND THE VALTYP OF THE VALUE ON THE STACK. APPLOP DECIDES WHAT VALUE LEVEL THE OPERATION WILL OCCUR AT, AND CONVERTS THE ARGUMENTS. APPLOP USES DIFFERENT CALLING CONVENTIONS FOR EACH VALUE TYPE.

  • INTEGERS: LEFT IN [D,E] RIGHT IN [H,L]
  • SINGLES: LEFT IN [B,C,D,E] RIGHT IN THE FAC
  • DOUBLES: LEFT IN FAC RIGHT IN ARG

2406APPLOP
POP BC
Get the precedence value and the token for the last operator from the stack and put it in BC.
2407
LD A,C
Load register A with the operator token in register C.
2408-240A
LD (40B0H),ALD (OPRTYP),A
Save the operator token in register A.
Note: 40B0H holds Temporary storage location.
240B
LD A,B
Load register A with the precedence value in register B.
240C-240D
CP 08H
Check the number type for the precedence value in register A.
240E-240F
Jump forward to 2438H if the number type in register A (the first operand) is double prec1sion.
2410-2412
LD A,(40AFH)LD A,(VALTYP)
Load register A with the number type for the current result in REG 1.
Note: 40AFH holds Current number type flag.
2413-2414
CP 08H
Check to see if the current result in REG 1 is double precision.
2415-2417
Jump forward to 2460H if the current value in REG 1 is double precision.
2418
LD D,A
Load register D with the current data type flag in register A.
2419
LD A,B
Load register A with the precedence value for the last operator in register B.
241A-241B
CP 04H
Check to see if the number type for the precedence value in register A is single precision.
241C-241E
Jump forward to 2472H if the number type for the precedence value in register A is single precision.
241F
LD A,D
Load register A with the number type flag for the value in REG 1.
2420-2421
CP 03H
Check to see if the current value in REG 1 is a string.
2422-2424
Display a ?TM ERROR message if the current value in REG 1 is a string.
2325-2427
Jump forward to 247CH if the current value in REG 1 is single precision.
2428-242A
LD HL,18BFHLD HL,INTDSP
Load HL with the starting address of the arithmetic jump table.
242B-242C
LD B,00H
Load register B with zero.
242D
ADD HL,BC
Add the operator's token in BC to the value of the arithmetic jump table pointer in HL.
242E
ADD HL,BC
Add the operator's token in BC to the value of the arithmetic jump table pointer in HL.
242F
LD C,(HL)
Load register C with the LSB of the jump address at the location of the arithmetic jump table pointer in HL.
2430
INC HL
Bump the value of the arithmetic jump table pointer in HL.
2431
LD B,(HL)
Load register B with the MSB of the jump address at the location of the arithmetic jump table pointer in HL.
2432
POP DE
Get the value for the previous result from the stack and put it in DE.
2433-2435
LD HL,(4121H)LD HL,(FACLO)
Get the value for the current result from REG 1 and put it in HL.
2436
PUSH BC
Save the arithmetic routine's jump address in regis? ter pair BC to the stack.
2437
RET
Return.

THE STACK OPERAND IS DOUBLE PRECISION, SO THE FAC MUST BE FORCED TO DOUBLE PRECISION, MOVED INTO ARG AND THE STACK VALUE POPED INTO THE FAC

2438-243ASTKDBL
Call the CONVERT TO DOUBLE PRECISION routine at 0ADBH (where the contents of REG 1 are converted from integer or single precision to double precision).
243B-243D
Go convert the current result in REG 1 to single precision.
243E
POP HL
Get the value from the stack and put it in HL.
243F-244l
LD (411FH),HLLD (DFACLO+2),HL
Save the value in HL near the end of REG 1.
2442
POP HL
Get the value from the stack and put it in HL.
2443-2445
LD (411DH),HLLD (DFACLO),HL
Save the value in HL in REG 1.
Note: 411DH-4124H holds REG l.
2446SNGDBL
POP BC
Get the value from the stack and put it in BC.
2447
POP DE
Get the value from the stack and put it in DE.
2448-244A
CALL 09B4HCALL MOVFR (which moves the SINGLE PRECISION value in DC/DE into REG 1). This moves DE to (4121H) and BC to (4123H).
244B-244DSETDBL
Convert the first value to double precision by calling the CONVERT TO DOUBLE PRECISION routine at 0ADBH (where the contents of REG 1 are converted from integer or single precision to double precision).
244E-2450
LD HL,18ABHLD HL,DBLDSP
Load HL with the double precision arithmetic jump table's starting address.
2451-2453DODSP
LD A,(40B0H)LD A,(OPRTYP)
Load register A with the operator token in register A.
Note: 40B0H holds Temporary storage location.
2454
RLCA
Multiply the value of the operator token in register A by two.
2455
PUSH BC
Save the value in BC to the stack so we can use it for 16 bit arithmetic.
2456
LD C,A
Load register C with the adjusted value of the operator token in register A (i.e., 2 x token).
2457-2458
LD B,00H
Load register B with zero.
2459
Add the value of the adjusted operator token in BC (which is token value * 2) to 18ABH (which is the double precision arithmetic jump table's starting address) in HL.
245A
POP BC
Restore BC from the stack and put it in BC.
245B
LD A,(HL)
Load register A with the LSB of the jump address at the location of the arithmetic jump table pointer in HL.
245C
INC HL
Bump the value of the arithmetic jump table pointer in HL.
245D
LD H,(HL)
Load register H with the MSB of the jump address at the location of the arithmetic jump table pointer in HL.
245E
LD L,A
Load register L with the LSB of the jump address in register A.
245F
JP (HL)
Jump to the arithmetic routine whose address is in HL.

THE FAC IS DOUBLE PRECISION AND THE STACK IS EITHER INTEGER OR SINGLE PRECISION AND MUST BE CONVERTED

2460FACDBL
PUSH BC
Save the precedence value and the operator token in BC to the stack.
2461-2463
Move the current result to the a storage area.
2464
POP AF
Load register A with the value of the current number type flag.
2465-2467
LD (40AFH),ALD (VALTYP),A
Save the value of the current number type flag in register A.
Note: 40AFH holds Current number type flag.
2468-2469
CP 04H
Check to see if the current result in REG 1 is single precision.
246A-246B
Jump back to 2446H if the current result in REG 1 is single precision.
246C
POP HL
Get the integer value from the stack and put it in HL.
246D-246F
LD (4121H),HLLD (FACLO),HL
Save the integer value in HL in REG 1.
2470-2471
Jump back to 244BH.

THIS IS THE CASE WHERE THE STACK IS SINGLE PRECISION AND THE FAC IS EITHER SINGLE PRECISION OR INTEGER

2472-2474STKSNG
Call the CONVERT TO SINGLE PRECISION routine at 0AB1H (which converts the contents of REG 1 from integer or double precision into single precision).
2475
POP BC
Get the value from the stack and put it in BC.
2476
POP DE
Get the value from the stack and put it in DE.
2477-2479SNGDO
LD HL,18B5HLD HL,SNGDSP
Load HL with the starting address of the single precision arithmetic jump table.
247A-247B
Jump back to 2451H to perform the operation.

THIS IS THE CASE WHERE THE FAC IS SINGLE PRECISION AND THE STACK IS AN INTEGER.

247CFACSNG
POP HL
Get the integer value from the stack and put it in HL.
247D-247F
Call 09A4 which moves the SINGLE PRECISION value in REG 1 to the stack (stored in LSB/MSB/Exponent order).
2480-2482
Go convert the integer value in HL to single precision.
2483-2485
Call 09BF which loads the SINGLE PRECISION value in REG 1 into BC/DE.
2486
POP HL
Get the LSB/NMSB from the stack and put it in HL.
2487-2489
LD (4123H),HLLD (FAC-1),HL
Save the value in HL in REG 1
248A
POP HL
Get the MSB and exponent from the stack and put it in HL.
248B-248D
LD (4121H),HLLD (FACLO),HL
Save the value in HL in REG 1.
248E-248F
Jump back to 2477H to perform the operation.

2490 - Integer divide

(ACC=DE / HL) Result will be in single-precision (NTF=4) and will be in the ACC.
Divides DE by HL. Both values are converted to single precision before the division is started. The quotient is left in REG l; the mode flag is updated. The orginal contents of the DE and HL register sets are lost.

Note: To use a ROM call to divide two integers store the dividend in the DE register pair, and store the divisor in HL and then CALL 2490H. The result is stored in single precision format (since it is not likely to be an integer) in 4121H-4124Hin approximately 5.1 milliseconds.

2490HINTDIV
Save the integer value in HL to the stack.
2491
EX DE,HL
We need to convert DE to SP so first do this swap to set up the variables for the call which follows.
2492-2494
Go convert the integer value in HL to single precision and return with the result in REG 1.
2495
POP HL
Get the integer value from the stack and put it in HL.
2496-2498
Call 09A4 which moves the SINGLE PRECISION value in REG 1 to the stack (stored in LSB/MSB/Exponent order).
2499-249B
Go convert the integer value in HL to single precision and return with the result in REG 1.
249C-249E
Go do a single precision divide.
249FEVAL
RST 10H
We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
24A0-24A1
LD E,28HLD E,ERRMO
Load register E with a ?MO ERROR code.
24A2-24A4
Display a ?MO ERROR if we are at the end of the string.
24A5-24A7
If the character at the location of the current BASIC program pointer in HL is numeric, call the ASCII TO BINARY routine at 0E6C (which converts the ASCII string pointed to by HL to binary with the result in REG 1 and the mode flag will have changed).
24A8-24AA
Check to see if the character at the location of the current BASIC program pointer in HL is alphabetic.
24AB-24AD
Jump if the character at the location of the current BASIC program pointer in HL is alphabetic.
24AE-24AF
CP 0CDHCP PLUSTK
Check to see if the character at the location of the current BASIC program pointer in register A is a + token.

Notes:

  • CDH is a + in ASCII
  • A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
24B0-24B1
Jump if the character at the location of the current BASIC program pointer in register A is a + token.
24B2-24B3
CP 2EH
Check to see if the character at the location of the current BASIC program pointer in register A is a decimal point.

Notes:

  • 2EH is a . in ASCII
  • A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
24B4-24B6
If the character at the location of the current BASIC program pointer in HL is a decimal point, call the ASCII TO BINARY routine at 0E6C (which converts the ASCII string pointed to by HL to binary with the result in REG 1 and the mode flag will have changed).
24B7-24B8
CP 0CEHCP MINUTK
Check to see if the character at the location of the current BASIC program pointer in register A is a - token.

Notes:

  • CEH is a - in ASCII
  • A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
24B9-24BB
Jump to 2532H if the character at the location of the current BASIC program pointer in register A is a - token.
24BC-24BD
CP 22H
Check to see if the character at the location of the current BASIC program pointer in register A is a ".

Notes:

  • 22H is a " in ASCII
  • A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
24BE-24C0
Jump to 2866H if the character at the location of the current BASIC program pointer in register A is a ".
24C1-24C2
CP 0CBHCP NOTTK
Check to see if the character at the location of the current BASIC program pointer in register A is a NOT token.

Notes:

  • CBH is a NOT token.
  • A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
24C3-24C5
Jump to 25C4H if the character at the location of the current BASIC program pointer in register A is a NOT token.
24C6-24C7
CP 26H
Check to see if the character at the location of the current BASIC program pointer in register A is a &.

Notes:

  • 26H is a & in ASCII
  • A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
24C8-24CA
Jump to 4194H (which is DOS) if the character at the location of the current BASIC program pointer in register A is a &.
24CB-24CC
CP 0C3HCPI ERCTK
Check to see if the character at the location of the current BASIC program pointer in register A is an ERR token.

Notes:

  • C3H is a ERR token.
  • A CP will return Z if there is a match against Register A, and NZ if not a match against Register A.
24CD-24CE
Jump to 24D9H if the character at the location of the current BASIC program pointer in register A isn't an ERR token.
24CF
RST 10H
We now need bump the value of the current BASIC program pointer until it points to the next character, call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
24D0-24D2
LD A,(409AH)LD A,(ERRFLG)
Load register A with the value of the current error number.
Note: 409AH holds the RESUME flag.
24D3NTDERC
PUSH HL
Save the value of the current BASIC program pointer in HL to the stack.
24D4-24D6
Go save the value of the current error number in register A (as an integer) as the current result in REG l.
24D7
POP HL
Get the value of the current BASIC program pointer from the stack and put it in HL.
24D8
RET
Return.
24D9-24DANTERC
CP C2HCP ERLTK
Check to see if the character at the location of the current BASIC program pointer in register A is a ERL token.
24DB-24DC
Jump to 24E7H if the character at the location of the current BASIC program pointer in register A isn't an ERL token.
24DD
RST 10H
We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
24DE
PUSH HL
Save the value of the current BASIC program pointer in HL to the stack.
24DF-24El
LD HL,(40EAH)LD HL,(ERRLIN)
Load HL with the current error line number.
Note: 40EAH-40EBH holds the line number with error.
24E2-24E3
Go save the error line number in HL as the current result in REG 1.
24E5
POP HL
Get the value of the current BASIC program pointer from the stack and put it in HL.
24E6
RET
Return.

24E7-24FE - "VARPTR" logic

24E7-24E8NTERL
CP 0C0HCP $VARPTR
Check to see if the character at the location of the current BASIC program pointer in register A is a VARPTR token.
24E9-24EA
Jump back to 24FFH if the character at the location of the current BASIC program pointer in register A isn't a VARPTR token.
24EB
RST 10H
We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
24EC-24ED
RST 08H ⇒ 28
Since the character at the location of the current BASIC program pointer in HL must be a (, call the COMPARE SYMBOL routine at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL register to the value in the location following the RST 08 call.
  • If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
  • If the two characters do not match, a syntax error message is given and control returns to the Input Phase).
24EE-24F0
GOSUB to PTRGET to get the address of the variable.
24F1-24F2VARRET
RST 08H ⇒ 29
Since the character at the location of the current BASIC program pointer in HL must be a ), call the COMPARE SYMBOL routine which compares the symbol in the input string pointed to by HL register to the value in the location following the RST 08 call. If there is a match, control is returned to address of the RST 08 instruction + 2 with the next symbol in the A register and HL incremented by one. If the two characters do not match, a syntax error message is given and control returns to the Input Phase).
24F3
PUSH HL
Save the value of the current BASIC program pointer in HL to the stack.
24F4
EX DE,HL
Load HL with the variable's address in DE.
24F5
LD A,H
Load register A with MSB of the variable's address in register H.
24F6
OR L
Combine the LSB of the variable's address in register L with the MSB of the variable's address in register A. This type of pattern is used to check for something being zero.
24F7-24F9
Display a ?FC ERROR if the variable's address in HL is equal to zero, meaning that the variable is undefined.
24FA-24FC
Save the variable's address in HL as the current result in REG l.
24FD
POP HL
Get the value of the current BASIC program pointer from the stack and put it in HL.
24FE
RET
Return to the execution driver.

24FF - Other Function Routine

24FF-2500NTVARP
CP 0C1HCP USRTK
Check to see if the character at the location of the current BASIC program pointer in register A is a USR token.
2501-2503
Jump to 27FEH if the character at the location of the current BASIC program pointer in register A is a USR token.
2504-2505
CP 0C5HCP INSRTK
Check to see if the character at the location of the current BASIC program pointer in register A is a INSTR token
2506-2508
Jump to the DOS address of 419DH if the character at the location of the current BASIC program pointer in register A is an INSTR token.
2509-250A
CP 0C8HCP $MEM
Check to see if the character at the location of the current BASIC program pointer in register A is a MEM token.
250B-250D
If the character at the location of the current BASIC program pointer in register A is a MEM token, jump to the RETURN AMOUNT OF FREE MEMORY routine at 27C9H which computes the amount of memory remaining between the end of the variable list and the end of the stack and puts the result in REG 1 as a SINGLE PRECISION number.
250E-250F
CP 0C7HCP $TIME
Check to see if the character at the location of the current BASIC program pointer in register A is a TIME$ token.
2510-2512
Jump to the DOS address of 4176H if the character at the location of the current BASIC program pointer in register A is a TIME$ token.
2513-2514
CP 0C6HCP $POINT
Check to see if the character at the location of the current BASIC program pointer in register A is a POINT token.
2515-2517
Jump to 0132H if the character at the location of the current BASIC program pointer in register A is a POINT token.
2518-2519
CP 0C9HCP $INKEY
Check to see if the character at the location of the current BASIC program pointer in register A is an INKEY$ token.
251A-251C
Jump to 019DH if the character at the location of the current BASIC program pointer in register A is an INKEY$ token.
251D-251E
CP 0C4HCP $STRING
Check to see if the character at the location of the current BASIC program pointer in register A is a STRING$ token.
241F-2421
Jump to 2A2FH if the character at the location of the current BASIC program pointer in register A is a STRING$ token.
2522-2523
CP 0BEHCP FNTK
Check to see if the character at the location of the current BASIC program pointer in register A is a FN token.
2524-2526
Jump to the DOS address of 4155H if the character at the location of the current BASIC program pointer in register A is a FN token.
2527-2528
SUB 0D7HSUI ONEFUN
Check to see if the character at the location of the current BASIC program pointer in register A is a SGN to MID$ token.
2529-252B
Jump to 254EH if the character at the location of the current BASIC program pointer in register A is a SGN to MID$ token.
252C-252EPARCHK
GOSUB to 2335H to evaluate the expression at the location of the current BASIC program pointer in HL.
252F-2530
RST 08H ⇒ 29H
Since the character at the location of the current BASIC program pointer in HL must be a ), call the COMPARE SYMBOL routine at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL register to the value in the location following the RST 08 call.
  • If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
  • If the two characters do not match, a syntax error message is given and control returns to the Input Phase).
2531
RET
Return out of this routine.

2532 - Binary Minus Routine

2532DOMIN
LD D,7DH
Load register D with the precedence value.
2534-2536
GOSUB to 233AH to evaluate the variable at the location of the current BASIC program pointer in HL.
2537-2539
LD HL,(40F3H)LD HL,(TEMP2)
Load HL with the value of the current BASIC program pointer.
Note: 40F3H-40F4H holds Temporary storage location.
253A
PUSH HL
Save the value of the current BASIC program pointer in HL to the stack so we know where to continue.
253B-253D
Invert the sign of the current value in REG 1.
253ELABBCK
POP HL
Restore the code string address from the stack and put it in HL. We need this because we return here after executing functions SNG( to MID$(.
253F
RET
Return to the expression evaluation.

2540 - This routine loads a variable to the ACC and sets the NTF.

The HL must point to the ASCII variable name. After execution the HL will point to the character following the last character of the variable used. The value of the variable will be loaded in the ACC. For strings however (NTF=3), the ACC will contain the address of the first three bytes which contain the string length and string address (see Level II BASIC manual). Also note that if the variable cannot be found it will be created and given a value of zero.

2540-2542ISVAR
Call the FIND ADDRESS OF VARIABLE routine at 260DH which searches the Variable List Table for a variable name which matches the name in the string pointed to in HL, and return the address of that variable in DE (and if there is no variable, it creates it, zeroes it, and returns THAT location).
2543RETVAR
PUSH HL
Save the value of the current BASIC program pointer in HL to the stack.
2544
EX DE,HL
Move the address of the variable to HL.
2545-2547
LD (4121H),HLLD (FACLO),HL
Save the variable's address in HL in REG 1.
2548
RST 20H
We need to check the value of the current number type flag, so we call the TEST DATA MODE routine at RST 20H.
NOTE: The RST 20H routine determines the type of the current value in REG 1 and returns a combination of STATUS flags and unique numeric values in the A Register according to the data mode flag (40AFH).

The results are returned as follows:
If the Variable Type is ...and the Flags
are set ...		... then Register
A will be set ...
IntegerNZ/C/M/E-1
StringZ/C/P/E0
Single PrecisionNZ/C/P/O1
Double PrecisionNZ/NC/P/E5
2549-254B
If that test shows we do NOT have a STRING, call 09F7H to move data.
254C
POP HL
Get the address of the next symbol in the input string from the stack and put it in HL.
254D
RET
Return to the caller.

254E - This routine is for "SNG" to "MID$"

254E-254FISFUN
LD B,00H
Load register B with zero.
2550
RLCA
Set A to be 2 * (token - D7H)
2551
LD C,A
Save the new token.
2552
PUSH BC
Save 0/2*(token-D7) on stack.
2553
RST 10H
Get the next character from the tokenized string by calling RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2554
LD A,C
Prepare to look for SGN( to CHR$( token.
2555NUMGFN
CP 41HCP 2*LASNUM-2*ONEFUN+1
Test for the adjusted token.
2557
.Jump to 256FH if the token is SGN( to CHR$(. If not, it is a LEFT$ - MID$.

MOST FUNCTIONS TAKE A SINGLE ARGUMENT.
THE RETURN ADDRESS OF THESE FUNCTIONS IS A SMALL ROUTINE THAT CHECKS TO MAKE SURE VALTYP IS 0 (NUMERIC) AND POPS OFF THE TEXT POINTER. SO NORMAL FUNCTIONS THAT RETURN STRING RESULTS (I.E. CHR$) MUST POP OFF THE RETURN ADDRESS OF LABBCK, AND POP OFF THE TEXT POINTER AND THEN RETURN TO FRMEVL.
THE SO CALLED "FUNNY" FUNCTIONS CAN TAKE MORE THAN ONE ARGUMENT. THE FIRST OF WHICH MUST BE STRING AND THE SECOND OF WHICH MUST BE A NUMBER BETWEEN 0 AND 256. THE TEXT POINTER IS PASSED TO THESE FUNCTIONS SO ADDITIONAL ARGUMENTS CAN BE READ. THE TEXT POINTER IS PASSED IN [D,E]. THE CLOSE PARENTHESIS MUST BE CHECKED AND RETURN IS DIRECTLY TO FRMEVL WITH [H,L] SETUP AS THE TEXT POINTER POINTING BEYOND THE ")". THE POINTER TO THE DESCRIPTOR OF THE STRING ARGUMENT IS STORED ON THE STACK UNDERNEATH THE VALUE OF THE INTEGER ARGUMENT (2 BYTES)
FIRST ARGUMENT ALWAYS STRING -- SECOND INTEGER.

2559
Otherwise, GOSUB to 2335H to evaluate the expression part of the calling sequence (which requires 2 or parameters).
255C
RST 08H ⇒ 2CH
Use RST 08H to test for a ,.
255E
GOSUB to 0AF4H to ensure the current variable is a string, otherwise it is an error.
2561
EX DE,HL
Make sure the current variable is a string - DE is the current position in the program statement and HL is the address of the string.
2562
LD HL,(4121H)LD HL,(FACLO)
Load HL with the string address held at the memory location pointed to by REG 1.
2565
EX (SP),HL
Put the string address to the stack.
2566
PUSH HL
Save the 00 / 2*(token-D7H) to the stack.
2567
EX DE,HL
Move the program statement position to HL.
2568
Evaluate n portion of the string function.
256B
EX DE,HL
Set DE to be the current position in the statement and set HL to be n.
256C
EX (SP),HL
Move n to stack. HL will be 2 * (token - D7H).
256D
Jump down to 2583H to process the token.
256F-2571OKNORM
The below is a single variable parameter call. First, GOSUB to 252CH to evaluate the expression at the location of the current BASIC program pointer in HL.
2572
EX (SP),HL
Exchange the value of the current BASIC program pointer in HL with the operator value to the stack. HL will be 0 + 2 * (token - D7H).

CHECK IF SPECIAL COERCION MUST BE DONE FOR ONE OF THE TRANSCENDENTAL FUNCTIONS (RND, SQR, COS, SIN, TAN, ATN, LOG, AND EXP) THESE FUNCTIONS DO NOT LOOK AT VALTYP, BUT RATHER ASSUME THE ARGUMENT PASSED IN THE FAC IS SINGLE PRECISION, SO FRCSNG MUST BE CALLED BEFORE DISPATCHING TO THEM.

2573
LD A,L
Load register A with the operator token in register L. A will be 2 * (token - D7H).
2574-2575BOTCON
CP 0CHCP (SQRTK-ONEFUN)*2
Check to see if the operator token in register A is SGN to SQR.
2576-2577
Jump down to 257FH if the operator token in register A is SGN to SQR.
2578-2579TOPCON
CP 1BHCP (ATNTK-ONEFUN)*2+1
Check the value of the adjusted operator token in register A.
257A
PUSH HL
Save the adjusted token (0 + 2*(token - D7H)) in HL to the stack.
257B-257D
If the operator token in register A is SQR to ATN, call the CONVERT TO SINGLE PRECISION routine at 0AB1H (which converts the contents of REG 1 [4121H] from integer or double precision into single precision).
257E
POP HL
Restore the adjusted token from the stack and put it in HL.
257F-2581NOTFRF
LD DE,253EHLD D,LABBCK
Load DE with a return address of 253EH for once the function is executed.
2582
PUSH DE
Save the value of the return address in DE to the stack.
2583-2585FINGO
LD BC,1608HLD BC,FUNDSP
Load BC with the SGN to MID$ jump table address.
2586DISPAT
ADD HL,BC
Add the jump table pointer in BC with the value of the operator token in HL.
2587
LD C,(HL)
Load register C with the LSB of the jump address at the location of the jump table pointer in HL.
2588
INC HL
Bump the value of the jump table pointer in HL.
2589
LD H,(HL)
Load register H with the MSB of the jump address at the location of the jump table pointer in HL.
258A
LD L,C
Load register L with the LSB of the jump address in register C.
258B
JP (HL)
Jump to the calculated address (which is the SGN-MID$ function) in HL.

258C - This routine will do a relational comparison of two strings.
It will load A with the length of the first string and BC with the string's address. Then it will load D with the length of the second string and HL with the string's address. - "STRCMP"

THE FOLLOWING ROUTINE COMPARES TWO STRINGS; ONE WITH DESC IN [D,E] OTHER WITH DESC. IN [FACLO, FACLO+1]

  • A=0 IF STRINGS EQUAL
  • A=377 IF B,C,D,E .GT. FACLO
  • A=1 IF B,C,D,E .LT. FACLO

258C-258ESTRCMP
GOSUB to 29D7H to check to see if there is enough memory for the string.
258F
LD A,(HL)
Load register A with the length of the string at the location of the string's VARPTR in HL.
2590
INC HL
Bump the value of the string's VARPTR in HL so that HL points to the LSB of the string address.
2591
LD C,(HL)
Load register C with the LSB of the string's address at the location of the string's VARPTR in HL.
2592
INC HL
Bump the value of the string's VARPTR in HL so that HL points to the MSB of the string address.
2594
LD B,(HL)
Load register B with the MSB of the string's address at the location of the string's VARPTR in HL.
2595
POP DE
Save the value of the string's address in BC to the stack.
2596
PUSH BC
Save the string's length in register A to the stack.
2597-2599
PUSH AF
Load HL with the second string's VARPTR.
259A
POP DE
Get the length of the first string from the stack and put it in register D.
259B
LD E,(HL)
Load register E with the second string's length at the location of the second string's VARPTR in HL.
259C
INC HL
Bump the value of the second string's VARPTR in HL.
259D
LD C,(HL)
Load register C with the LSB of the second string's address at the location of the second string's VARPTR in HL.
259E
INC HL
Bump the value of the second string's VARPTR in HL.
259F
LD B,(HL)
Load register B with the MSB of the second string's address at the location of the second string's VARPTR in HL.
25A0
POP HL
Get the first string's address from the stack and put it in HL.
25A1CSLOOP
LD A,E
Load register A with the length of the second string in register E.
25A2
OR D
Combine the first string's length in register D with the second string's length in register A.
25A3
RET Z
Return out of the routine if there aren't any characters left in either string to be compared.
25A4
LD A,D
Load register A with the first string's length in register D.
25A5-25A6
SUB 01H
Check to see if the first string's length in register A is equal to zero.
25A7
RET C
Return if there are no more characters in the first string to be compared.
25A8
XOR A
Load register A with zero.
25A9
CP E
Check to see if the second string's length in register E is equal to zero.
25AA
INC A
Bump the value in register A.
25AB
RET NC
Return if there aren't anymore characters in the second string to be compared.
25AC
DEC D
Decrement the value of the first string's length in register D.
25AD
DEC E
Decrement the value of the second string's length in register E.
25AE
LD A,(BC)
Load register A with the character at the location of the second string pointer in BC.
25AF
CP (HL)
Compare the character at the location of the second string pointer in register A with the character at the location of the first string pointer in HL.
25B0
INC HL
Bump the value of the first string pointer in HL.
25Bl
INC BC
Bump the value of the second string pointer in BC.
25B2-25B3
Loop back to 25A1H to keep going if the characters match.
25B4
CCF
Since they are not equal, reverse the CARRY flag so 960 will give a +1 or -1.
25B5-25B7
Jump back to 0960H.
25B8DOCMP
INC A
Bump the value of the current precedence value in register A.
25B9
ADC A,A
Adjust the value of the current precedence value in register A. This will give a 1 with a NC if 0 or a 0 with C if FF.
25BA
POP BC
Get the last operator value from the stack and put it in BC.
25BB
AND B
Combine the precedence value in register B with the precedence value in register A.
25BC-25BD
ADD A,FFH
Adjust the value in register A. This will give a 0 if both are equal and a CARRY if they are unequal.
25BE
SBC A,A
Check to see if the precedence values in registers A and B match. This will set A=0 if equal, and A+1 if unequal.
25BF-25Cl
Call to 098DH. This will set the current value to 00 if A is positive, and to FF if A is negative.
If the values match, set the current result in zero. If they do not match, set the current result to -1.
25C2-25CJ
Jump forward to 25D6H to continue with the expression evaluation.

25C4 - NOT Handler

25C4-25C5NOTER
LD D,5AH
Load register D with the precedence value.
25C6-25C8
Go evaluate the expression.
25C9-25CB
Call the CONVERT TO INTEGER routine at 0A7FH (where the contents of REG 1 are converted from single or double precision to integer and deposited into HL).
25CC
LD A,L
Load register A with the LSB of the integer value.
25CD
CPL
Compliment the LSB of the integer value in register A.
25CE
LD L,A
Load register L with the adjusted LSB of the integer value in register A.
25CF
LD A,H
Load register A with the MSB of the integer value in register H.
25D0
CPL
Compliment the MSB of the integer value in register A.
25Dl
LD H,A
Load register H with the adjusted MSB of the integer value in register A.
25D2-25D4
LD (4121H),HLLD (FACLO),HL
Save the complimented integer value in HL as the current result in REG 1
25D5
POP BC
Clean up the stack.
25D6-25D8RETAPG
Jump back to 2346H to continue with the expression evaluation.

25D9 - The RST 20H code is located here. - This is the TEST DATA MODE, which determines the type of the current value in REG 1 and returns a combination of STATUS flags and unique numeric values in the A Register according to the data mode flag (40AFH) - "GETYPR".

TYPE   CODE   ZERO   CARRY   NEG   PARITY   A-Register
INT     02     NZ      C      N      E         -1
STR     03      Z      C      P      E          0
SNG     04     NZ      C      P      O          1
DBL     08     NZ     NC      P      E          5

25D9-25DBHGETYPR
LD A,(40AFH)LD A,(VALTYP)
Load register A with the current value of the number type flag.
Note: 40AFH holds Current number type flag.
25DC-25DD
CP 08H
Check to see if the current value in REG 1 is double precision (02=INT, 03=STR, 04=SNG, 08=DBL).
25DE-25DFCGETYP
If that test shows that we have a DOUBLE PRECISION number, jump forward to 25E5H.
25E0-25El
SUB 03H
If the number is not double precision, subtract 3.
25E2
OR A
Set the status flags of the adjusted number type flag in register A.
24E3
SCF
Set the Carry flag.
25E4
RET
Return.
25E5-25E6NCASE
SUB 03H
We are dealing with a double precision number so adjust the value of the current number type flag in register A.
25E7
OR A
Test the value of the current number type flag in register A, which will exit without the CARRY flag set.
25E8
RET
Return.

DANDOR APPLIES THE "AND" AND "OR" OPERATORS AND SHOULD BE USED TO IMPLEMENT ALL LOGICAL OPERATORS. WHENEVER AN OPERATOR IS APPLIED, ITS PRECEDENCE IS IN [B]. THIS FACT IS USED TO DISTINGUISH BETWEEN "AND" AND "OR". THE RIGHT HAND ARGUMENT IS COERCED TO INTEGER, JUST AS THE LEFT HAND ONE WAS WHEN IT WAS PUSHED ON THE STACK.

25E9DANDOR
PUSH BC
B has he precision alue for the last operator. Save BC to the stack.
25EA-25EC
Call the CONVERT TO INTEGER routine at 0A7FH (where the contents of REG 1 are converted from single or double precision to integer and deposited into HL).
25ED
POP AF
Get the operator value from the stack and put it in register A.
25EE
POP DE
Get the return address from the stack and put it in DE.
25EF-25F1
LD BC,27FAHLD BC,GIVINT
Load BC with a return address of 27FAH.
25F2
PUSH BC
Save the value of the return address in BC to the stack.
25F3-25F4
CP 46H
Check to see if the operator value in register A is an OR token. A CP returns Z if the test matches A and NZ otherwise.
25F5-25F6
Jump forward a few instructions to 25FDH (to the AND code) if the operator value in register A isn't an OR token.

25F7 - OR logic handler

25F7
LD A,E
Load register A with the LSB of the first value in register E.
25F8
OR L
Combine the LSB of the first value in register A with the LSB of the second value in register L.
25F9
LD L,A
Load register L with the ORed value in register A.
25FA
LD A,H
Load register A with the MSB of the second value in register H.
25FB
OR D
Combine the MSB of the first value in register D with the MSB of the second value in register A.
25FC
Return to 27FAH (=convert the result to integer and return that integer calue to 2346H).

25FD - AND logic handler

25FDNOTOR
LD A,E
Load register A with the LSB of the first value in register E.
25FE
AND L
Combine the LSB of the first value in register A with the LSB of the second value in register L.
25FF
LD L,A
Load register L with the ANDed value in register A.
2600
LD A,H
Load register A with the MSB of the second value in register H.
2601
AND D
Combine the MSB of the first value in register D with the MSB of the second value in register A.
2602
Return to 27FAH (=Make the result an integer and return to 2346H).

2603 - Dimension and Variable Searching

2603DIMCON
DEC HL
Decrement the value of the BASIC program pointer in HL.
2604
RST 10H
We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2605
RET Z
Return if this is the end of the BASIC statement.
2606-2607
RST 08H ⇒ 2CH
Since the character at the location of the current BASIC program pointer in HL must be a ,, call the COMPARE SYMBOL routine at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL register to the value in the location following the RST 08 call.
  • If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
  • If the two characters do not match, a syntax error message is given and control returns to the Input Phase).

2608 - DIM Routine

THE "DIM" CODE SETS DIMFLG AND THEN FALLS INTO THE VARIABLE SEARCH ROUTINE. THE VARIABLE SEARCH ROUTINE LOOKS AT DIMFLG AT THREE DIFFERENT POINTS:

  1. IF AN ENTRY IS FOUND, DIMFLG BEING ON INDICATES A "DOUBLY DIMENSIONED" VARIABLE
  2. WHEN A NEW ENTRY IS BEING BUILT DIMFLG'S BEING ON INDICATES THE INDICES SHOULD BE USED FOR THE SIZE OF EACH INDICE. OTHERWISE THE DEFAULT OF TEN IS USED.
  3. WHEN THE BUILD ENTRY CODE FINISHES, ONLY IF DIMFLG IS OFF WILL INDEXING BE DONE

2608-260ADIM
LD BC,2603HLD BC,DIMCON
Load BC with a return address of 2603H.
260B
Save the return address of 2603H (in BC) to the stack.

260D - This is the variable location and creation logic.

This routine will return the address of a variable in memory or create it if it is not found. In order to use this routine, the HL must point to the variable name (ASCII). Then, after execution, HL will point to the character following the variable name and the location of the variable will be returned in the DE register pair. For integer, single or doubleprecision (NTF=2, 4 or 8) the address returned in DE will be the same as for the VARPTR command under BASIC. (see Level II BASIC manual on VARPTR) For strings (NTF=3) however the address returned in DE will point to the first of three bytes containing the string length and string address.
This entry point searches the Variable List Table (VLT) for a variable name which matches the name in the string pointed to by HL. If the variable exists, its address is returned in DE. If it is not defined, then it is created with an initial value ofzero and its address is returned in DE. Dimensioned and non-dimensioned variables may be located, and suffixs for data mode may be included in the name string. A byte of machine zeros must terminate the name string. All registers are used.

260C-260D
OR AFH
Z-80 Trick. When passing through it will turn on some bits in register A.

ROUTINE TO READ THE VARIABLE NAME AT THE CURRENT TEXT POSITION AND PUT A POINTER TO ITS VALUE IN [D,E]. [H,L] IS UPDATED TO POINT TO THE CHARACTER AFTER THE VARIABLE NAME. VALTYP IS SETUP. NOTE THAT EVALUATING SUBSCRIPTS IN A VARIABLE NAME CAN CAUSE RECURSIVE CALLS TO PTRGET SO AT THAT POINT ALL VALUES MUST BE STORED ON THE STACK. ON RETURN, [A] DOES NOT REFLECT THE VALUE OF THE TERMINATING CHARACTER

260DPTRGET
XOR A
Z-80 Trick. When JUMPED here, Register A will be 0 instead.
260E-2610
LD (40AEH),ALD (DIMFLG),A
Save the value in register A as the current variable location/creation flag.
Note: 40AEH holds LOCATE/CREATE variable flag.
2611
LD B,(HL)
Load register B with the first character of the variable name.
2612-2614PTRGT2
GOSUB to 1E3DH to make sure the first character of the variable name is a letter.
2615-2617
Display a ?SN ERROR if the first character of the variable name isn't a letter.
2618
XOR A
Zero register A.
2619
LD C,A
Zero register C.
261A
RST 10H
We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
261B-261C
Jump to 2622H if the character at the location of the current BASIC program pointer in register A is numeric.
261D-261F
GOSUB to 1E3DH to check to see if the character at the location of the current BASIC program pointer is a letter.
2620-2621
Jump to 262BH if the character at the location of the current BASIC program pointer in register A isn't a letter.
2622ISSEC
LD C,A
Load register C with the second character of the variable name in register A.
2623EATEM
RST 10H
We now need bump the value of the current BASIC program pointer until it points to the next character, call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2624-2625
Loop back one optcode until a nonnumeric character is found.
2626-2628
Go check to see if the character at the location of the current BASIC program pointer in HL is alphabetic.
2629-262A
Jump back to 2623H if the character at the location of the current BASIC program pointer in HL is alphabetic.
262B-262DNOSEC
LD DE,2652HLD DE,HAVTYP
Load DE with a return address of 2652H.
262E
PUSH DE
Save the value of the return address in DE to the stack.
262F-2630
LD D,02H
Load register D with an integer number type flag.
2631-2632
CP 25H
Check to see if the character at the location of the current BASIC program pointer in register A is a %.
2633
RET Z
Return if the character at the location of the current BASIC program pointer in register A is a %.
2634
INC D
Bump register D so that it will be equal to a string number type flag (02=INT, 03=STR, 04=SNG, 08=DBL).
2635-2636
CP 24H
Check to see if the character at the location of the current BASIC program pointer in register A is a $.
2637
RET Z
Return if the character at the location of current BASIC program pointer in register A is a $.
2638
INC D
Bump register D so that it will be equal to a single precision number type flag (02=INT, 03=STR, 04=SNG, 08=DBL).
2639-263A
CP 21H
Check to see if the character at the location of the current BASIC program pointer in register A is a !.
263B
RET Z
Return if the character at the location of the current BASIC program pointer in register A is a !.
263C-263D
LD D,08H
Load register D with a double precision number type flag. We have to do this because 04H (SNG) would bump to 05H if we just did another INC, but we need 08H for DBL.
263E-263F
CP 23H
Check to see if the character at the location of the current BASIC program pointer in register A is a #.
2640
RET Z
Return if the character at the location of the current BASIC program pointer in register A is a #.
2641
LD A,B
Load register A with the first character of the variable name in register B.
2642-2643
SUB 41H
Adjust the value of the first character of the variable name in register A so that it is in the range of 0 to 25.
2644-2645
AND 7FH
Make sure the sign bit in register A isn't set by ANDing it against 0111 1111.
2646
LD E,A
Load register E with the adjusted first character of the variable name in register A.
2647-2648
LD D,00H
Load register D with zero.
2649
PUSH HL
Save the value of the current BASIC program pointer in HL to the stack.
264A-264C
LD HL,4101HLD HL,DEFTBL
Load HL with the starting address of the variable declaration table.
NOTE: 4101H-411AH holds Variable Declaration Table.
264D
ADD HL,DE
Add the value of the first character of the variable name in DE to the starting address of the variable declaration table in HL.
264E
LD D,(HL)
Load register D with the number type value at the location of the variable declaration table pointer in HL.
264F
POP HL
Get the value of the current BASIC program pointer from the stack and put it in HL.
2650
DEC HL
Decrement the value of the current BASIC program pointer in HL.
2651
RET
Return with data type in D.
2652HAVTYP
LD A,D
Load register A with the value of the number type flag in register D.
2653-2655
LD (40AFH),ALD (VALTYP),A
Save the number type flag for the current variable name in register A.
NOTE: 40AFH holds Current number type flag.
2656
RST 10H
We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2657-2659
LD A,(40DCH)LD A,(SUBFLG)
Load register A with the FOR flag.
Note: 40DCH holds FOR flag.
265A
OR A
Test the value of the FOR flag in register A.
265B-265D
Jump to 2664H if a FOR statement is being processed.
265E
LD A,(HL)
Re-fetch the next element of the code string by loading register A with the character at the location of the current BASIC program pointer in HL.
265F-2660
SUB 28H
Check to see if the character at the location of the current BASIC program pointer in register A is a (.
2661-2663
Jump to 26E9H if the character at the location of the current BASIC program pointer in register A is a ( (meaning, it is a subscripted variable).
2664NOARYS
XOR A
Zero register A.
2665-2667
LD (40DCH),ALD (SUBFLG),A
Set the array flag to 'no subscript'.
Note: 40DCH holds FOR flag.
2668
PUSH HL
Save the value of the current BASIC program pointer in HL to the stack.
2669
PUSH DE
Save the number type flag for the variable in DE to the stack.
266A-266C
LD HL,(40F9H)LD HL,(VARTAB)
Load HL with the value of the simple variables pointer.
  • Note: 40F9H-40FAH holds the starting address of the simple variable storage area.
266DLOPFND
EX DE,HL
Load DE with the simple variables pointer in HL. We don't care what happens to HL.
266E-2670
LD HL,(40FBH)LD HL,(ARYTAB)
Load HL with the array variables pointer.
  • Note: 40FBH-40FCH holds the starting address of the BASIC array variable storage area.
2671
RST 18H
Now we need to compare the value of the simple variables pointer in DE with the array variables pointer in HL, so we call the COMPARE DE:HL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2672
POP HL
Get the number type flag for the variable from stack and put it in HL.
2673-2674
Jump to 268EH if the simple variables pointer in DE is greater than or equal to the array variables pointer (meaning the variable wasn't defined).
2675
LD A,(DE)
Load register A with the number type flag for the variable at the location of the simple variables pointer in DE.
2676
LD L,A
Load register L with the number type flag in register A.
2677
CP H
Compare the number type flag for the variable in register H to the number type flag in register A.
2678
INC DE
Bump the value of the current simple variables pointer in DE to the 2nd character name for this entry.
2679-267A
Jump to 2686H (i..e, the next variable in the list) if the number type flags don't match.
267B
LD A,(DE)
Since the type matches, compare the 2nd character of the name by loading register A with the first character of variable name at the location of the simple variables pointer in DE.
267C
CP C
Compare the character at the location of the simple variables pointer in register A with the first character of the variable name in register C.
267D-2637
Jump to 2686H if the first characters of the variable names don't match.
267F
INC DE
Bump the value of the current simple variables pointer in DE.
2680
LD A,(DE)
Load register A with the second character of the variable name at the location of the simple variables pointer in DE.
2681
CP B
Compare the character at the location of the simple variables pointer in register A with the first character of the variable name in register B.
2682-2684
Jump to 26CCH if the character at the location of the simple variables pointer in register A matches the first character of the variable name in register B.
2685-2686
LD A,13H
Z-80 Trick to skip the next INC DE if continuing through.
2686NOTIT1
INC DE
Bump to the next entry in the simple variable list part 1.
2687
INC DE
Bump the value of the simple variables pointer in DE part 2.
2688
Save the number type flag for the variable in HL to the stack so that it can be re-loaded at 2672H.
2689-268A
LD H,00H
Load register H with zero.
268B
ADD HL,DE
Add the value of the simple variables pointer in DE to the value of the number type flag in HL.
268C-268D
Loop back to 266DH.
268ENOTFNS
LD A,H
Load register A with the number type flag for the variable in register H.
268F
POP HL
Get the value of the current BASIC program pointer from the stack and put it in HL.
2690
EX (SP),HL
Exchange the value of the current BASIC program pointer in HL with the value to the stack.
2691
PUSH AF
Save the number type flag for the variable in register A to the stack.
2692
PUSH DE
Save the start of the array variables pointer in DE to the stack.
2693-2695
LD DE,24F1HLD DE,VARRET
Load DE with a VARPTR locator return address of 24F1H.
2696
RST 18H
Now we need to compare the return address in DE with the return address in HL, so we call the COMPARE DE:HL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2697-2698
Jump forward to 26CFH if this routine is called from the VARPTR routine.
2699-269B
LD DE,2543HLD D,RETVAR
Load DE with a return address of the find address of variables routine at 2543H.
269C
RST 18H
We need to see if we were called from the 'find address of variable' routine so we need to compare the return address in DE with the return address in HL, so we call the COMPARE DE:HL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
269D
POP DE
Get the value of the array variables pointer from the stack and put it in DE.
269E-269F
Jump to 26D5H if this routine is called to locate the variables address.
26A0
POP AF
Clear the stack and put the value of the number type flag for the variable from the stack and put it in register A.
26Al
EX (SP),HL
Exchange the value of the current BASIC program pointer to the stack with the value of the return address in HL.
26A2
PUSH HL
Save the value of the current BASIC program pointer in HL to the stack.
26A3
PUSH BC
Save the variable's name in BC to the stack.
26A4
LD C,A
Load register C with the value of the number type flag for the variable in register A.
26A5-26A6
LD B,00H
Load register B with zero.
26A7
PUSH BC
Save the variable's number type flag in BC to the stack.
26A8
INC BC
Bump the value of the variable's number type flag in BC.
26A9
INC BC
Bump the value of the variable's number type flag in BC.
26AA
INC BC
Bump the value of the variable's number type flag in BC. Now that we are done bumping BC, we have the type + 3 (which is 3 bytes of overhead and a spare for the variable).
26AB-26AD
LD HL,(40FDH)LD HL,(STREND)
Load HL with the value of the free memory pointer.
Note: 40FDH-40FEH holds Free memory pointer.
26AE
PUSH HL
Save the value of the free memory pointer in HL to the stack.
26AF
ADD HL,BC
Add the value of the variable's number type flag in BC to the value of the free memory pointer in HL.
26B0
POP BC
Get the value of the free memory pointer from the stack and put it in BC.
26Bl
PUSH HL
Save the value of the new free memory pointer in HL to the stack.
26B2-26B4
Move the array variables up in memory.
26B5
POP HL
Get the value of the new free memory pointer from the stack and put it in HL.
26B6-26B8
LD (40FDH),HLLD (STREND),HL
Save the value of the new free memory pointer in HL to lock in that variable space.
NOTE: 40FDH-40FEH holds Free memory pointer.
26B9
LD H,B
Load register H with the MSB of the new array variables pointer in register B.
26BA
LD L,C
Load register L with the LSB of the new array variables pointer in register C.
26BB-26BD
LD (40FBH),HLLD (ARYTAB),HL
Save the value of the new array variables pointer in HL.
  • Note: 40FBH-40FCH holds the starting address of the BASIC array variable storage area.
26BEZEROER
DEC HL
Decrement the value of the array variables pointer in HL.
26BF-26C0
LD (HL),00H
Zero the location of the memory pointer in HL.
26Cl
RST 18H
Now we need to check to see if the variable has been completely zeroed, so we call the COMPARE DE:HL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
26C2-26CJ
Loop back to 26BEH until the variable has been cleared.
26C4
POP DE
Get the value of the variable's number type flag from the stack and put it in DE.
26C5
LD (HL),E
Save the value of the number type flag in register E at the location of the memory pointer in HL.
26C6
INC HL
Bump the value of the memory pointer in HL.
26C7
POP DE
Get the 2nd character of the variable's name from the stack and put it in DE.
26C8
LD (HL),E
Save the first character of the variable's name in register E at the location of the memory pointer in HL.
26C9
INC HL
Bump the value of the memory pointer in HL.
26CA
LD (HL),D
Save the first character of the variable's name in register D at the location of the memory pointer in HL.
26CB
EX DE,HL
Load DE with the value of the variable pointer in HL.
26CCFINPTR
INC DE
Bump the value of the variable pointer in DE.
26CD
POP HL
Get the value of the current BASIC program pointer from the stack and put it in HL.
26CE
RET
Return.
26CFVARNOT
LD D,A
Load register D with the value of the current number type flag in register A.
26D0
LD E,A
Load register E with the value of the current number type flag in register A.
26D1
POP AF
Clean up the stack.
26D2
POP AF
Clean up the stack.
26D3
EX (SP),HL
Exchange the value of the return address in HL with the value of the current BASIC program pointer to the stack.
26D4
RET
Return to the VARPTR routine.

26D5 - This routine is to locate a subscripted variable

26D5-26D7FINZER
LD (4124H),ALD (FAC),A
Zero REG 1.
26D8
POP BC
Clean up the stack.
26D9
LD H,A
Zero register H.
26DA
LD L,A
Zero register L.
26DB-26DD
LD (4121H),HLLD (FACLO),HL
Zero the string pointer location in REG 1.
26DE
RST 20H
We need to check the value of the current number type flag, so we call the TEST DATA MODE routine at RST 20H.
NOTE: The RST 20H routine determines the type of the current value in REG 1 and returns a combination of STATUS flags and unique numeric values in the A Register according to the data mode flag (40AFH).

The results are returned as follows:
If the Variable Type is ...and the Flags
are set ...		... then Register
A will be set ...
IntegerNZ/C/M/E-1
StringZ/C/P/E0
Single PrecisionNZ/C/P/O1
Double PrecisionNZ/NC/P/E5
26DF-26E0
If that test shows we do NOT have a STRING, jump to 26E7H.
26E1-26E3
LD HL,1928HLD HL,REDDY-1
Load HL with the starting address of the Level II BASIC READY message.
26E4-26E6
LD (4121H),HLLD (FACLO),HL
Save the value in HL as the current string pointer.
26E7POPHR2
POP HL
Get the value of the current BASIC program pointer from the stack and put it in HL.
26E8
RET
Return.

26E9 - This routine locates the address of a subscripted variable

On entry D = the type of variable, B = the 1st character of the variable name, C = the 2nd character of the variable name, and HL = the current position in the input string.

26E9ISARY
PUSH HLISARY
Save the value of the current BASIC program pointer in HL to the stack.
26EA-26EC
LD HL,(40AEH)LD HL,(DIMFLG)
Load HL with the value of the locate/create flag.
Note: 40AEH holds LOCATE/CREATE variable flag and will be a 0 if in locate mode and anything other than zero if in create mode.
26ED
EX (SP),HL
Exchange the value of the locate/create flag in HL with the value of the current BASIC program pointer to the stack.
26EE
LD D,A
Zero register D.
26EFINDLOP
PUSH DE
Save the variable's number type flag in DE to the stack.
26F0
PUSH BC
Save the variable's name in BC to the stack.
26Fl-26F3
Go evaluate the array subscript at the location of the current BASIC program pointer in HL up to a ) or ,. Return with the binary value in DE.
26F4
POP BC
Get the variable's name from the stack (1st and 2nd character) and put it in BC.
26F5
POP AF
Get the variable's number type flag from the stack and put it in register A.
26F6
EX DE,HL
Exchange the value of the array subscript in DE with the value of the current BASIC program pointer in HL.
26F7
EX (SP),HL
Exchange the value of the array subscript in HL with the value of the locate/create flag to the stack.
26F8
PUSH HL
Save the value of the locate/create flag in HL to the stack.
26F9
EX DE,HL
Exchange the value of the locate/create flag in HL with the value of the current BASIC program pointer in DE.
26FA
INC A
Bump the number of subscripts evaluated in register A.
26FB
LD D,A
Load register D with the number of subscripts evaluated in register A.
26FC
LD A,(HL)
Load register A with the character at the location of the current BASIC program pointer in HL.
26FD-26FE
CP 2CH
Check to see if the character at the location of the current BASIC program pointer in register A is a ,.
26FF-2700
Jump if the character at the location of the current BASIC program pointer in register A is a ,.
2701-2702
RST 08H ⇒ 29H
Since the character at the location of the current BASIC program pointer in HL must be a ), call the COMPARE SYMBOL routine at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL register to the value in the location following the RST 08 call.
  • If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
  • If the two characters do not match, a syntax error message is given and control returns to the Input Phase).
2703-2705SUBSOK
LD (40F3H),HLLD (TEMP2),HL
Save the value of the current BASIC program pointer in HL.
2706
Get the value of the locate/ create flag from the stack and put it in HL.
NOTE: 40F3H-40F4H holds Temporary storage location.
2707-2709
LD (40AEH),HLLD (DIMFLG),HL
Save the value of the locate/create flag in HL.
NOTE: 40AEH holds LOCATE/CREATE variable flag.
270A
PUSH DE
Save the number of subscripts evaluated in DE.

AT THIS POINT [B,C]=LOOKS. THE TEXT POINTER IS IN TEMP2. THE INDICES ARE ALL ON THE STACK, FOLLOWED BY THE NUMBER OF DIMENSIONS.

270B-270D
LD HL,(40FBH)LD HL,(ARYTAB)
Load HL with the value of the array variables pointer.
  • Note: 40FBH-40FCH holds the starting address of the BASIC array variable storage area.
270E-270F
LD A,19H
Z-80 Trick to skip the next command of ADD HL, DE if falling through.
270FLOPFDA
Figure the end of the array. Note: 40FBH-40FCH holds the array variables pointer.
2710
EX DE,HL
Load DE with the value of the array variables pointer in HL.
2711-2713
LD HL,(40FDH)LD HL,(STREND)
Load HL with the value of the free memory pointer.
Note: 40FDH-40FEH holds Free memory pointer.
2714
EX DE,HL
Exchange the value of the free memory pointer in HL with the value of the array variables pointer in DE.
2715
RST 18H
Now we need to compare the value of the free memory pointer in DE to the value of the array variables pointer in HL, so we call the COMPARE DE:HL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2716-2718
LD A,(40AFH)LD A,(VALTYP)
Load register A with the value of the current number type flag.
Note: 40AFH holds Current number type flag.
2719-271A
Jump forward out of this loop to 2742H if the array variables pointer in HL is greater than or equal to the value of the free memory pointer in DE.
271B
CP (HL)
Compare the value of the variable's number type flag in register A with the value of the number type flag at the location of the array variables pointer in HL.
271C
INC HL
Bump the value of the array variables pointer in HL.
271D-271E
Jump forward (but still in this loop) to 2727H if the number type flags don't match.
271F
LD A,(HL)
Load register A with the first character of the variable name at the location of the array variables pointer in HL.
2720
CP C
Check to see if the first character of the variable at the location of the array variable pointer in register A matches the first character of the variable name in register C.
2721
INC HL
Bump the value of the array variables pointer in HL.
2722-2723
Jump forward (but still in this loop) to 2728H if the first characters of the variable names don't match.
2724
LD A,(HL)
Load register A with the second character of the variable name at the location of the array variables pointer in HL.
2725
CP B
Compare the second character of the variable name at the location of the array variables pointer in register A matches the second character of the variable name in register B.
2726-2727
LD A,23H
Z-80 TRICK. Skips the next byte if passing through.
2727NMARY2
INC HL
Z-80 TRICK. Executes only if jumped here. Bump the value of the array variables pointer in HL.
2728NMARY1
INC HL
Bump the value of the array variables pointer in HL.
2729
LD E,(HL)
Load register E with the LSB of the offset to the next array at the location of the array variables pointer in HL.
272A
INC HL
Bump the value of the array variables pointer in HL.
272B
LD D,(HL)
Load register D with the MSB of the offset to the next array at the location of the array variables pointer in HL.
272C
INC HL
Bump the value of the array variables pointer in HL.
272D-272E
Jump back to 270FH if the variables' names don't match.
272F-2731
LD A,(40AEH)LD A,(DIMFLG)
Load register A with the value of the locate/create flag.
Note: 40AEH holds LOCATE/CREATE variable flag.
2732
OR A
Check the status of the locate/create flag in register A.
2733-2734
LD E,12H
Load register E with the ?DD ERROR code.
2735-2737
Display a ?DD ERROR message if the locate/create flag in register A indicates the create mode since that variable already exists.

TEMP2=THE TEXT POINTER. WE HAVE LOCATED THE VARIABLE WE WERE LOOKING FOR AT THIS POINT [H,L] POINTS BEYOND THE SIZE TO THE NUMBER OF DIMENSIONS THE INDICES ARE ON THE STACK FOLLOWED BY THE NUMBER OF DIMENSIONS

2738
POP AF
Get the number of subscripts evaluated from the stack and put it in register A.
2739
SUB (HL)
Compare the number of subscripts evaluated in register A with the number of subscripts for the array at the location of the array variables pointer in HL (meaning, the number which was DIMmed).
273A-273C
Jump down to 2795H if the number of subscripts evaluated in register A matches the number of subscripts for the array at the location of the array variables pointer in HL.

273D - BS ERROR entry point

273D-273EBSERR
LD E,10H
Load register E with a ?BS ERROR code.
273F-2741
Display a ?BS ERROR message if the number of subscripts evaluated in register A doesn't match the number of subscripts for the array at the location of the array variable pointer in HL.

2742 - HERE WHEN VARIABLE IS NOT FOUND IN THE ARRAY TABLE

2742NOTFDD
LD (HL),A
Save the number of subscripts for the array in register A at the location of the array variables pointer in HL.
2743
INC HL
Bump the value of the array variables pointer in HL so it points to the 2nd character in the variable name (since they are saved in last, first order).
2744
LD E,A
Load register E with the number type flag for the current variable.
2745-2746
LD D,00H
Zero register D.
2747
POP AF
Get the number of subscripts evaluated from the stack and put it in register A.
2748
LD (HL),C
Save the second character of the variable's name in register C at the location of the array variables pointer in HL.
2749
INC HL
Bump the value of the array variables pointer in HL to now point to the 1st character in the variable name (since they are saved in last, first order).
274A
LD (HL),B
Save the first character of the variable's name in register B at the location of the array variables pointer in HL.
274B
INC HL
Bump the value of the array variables pointer in HL to the LSB of the offset to the next entry.
274C
LD C,A
Load register C with the number of subscripts evaluated in register A.
274D-274F
Figure the amount of memory space left between HL and the free memory.
2750
INC HL
Bump the value of the array variables pointer in HL.
2751
INC HL
Bump the value of the array variables pointer in HL. These 2 INC's skip over the offset entry.
2752-2754
LD (40D8H),HLLD (TEMP3),HL
Save the value of the array variables pointer in HL to 40D8H (which is the address of the maximum number of indices).
Note: 40D8H-40D9H holds temporary storage location.
2755
LD (HL),C
Save the number of subscripts evaluated in register C (1, 2, or 3) at the location of the array variables pointer in HL.
2756
INC HL
Bump the value of the array variables pointer in HL to point to the first subscript entry in the array table.
2757-2759
LD A,(40AEH)LD A,(DIMFLG)
Load register A with the value of the locate/create flag.
Note: 40AEH holds LOCATE/CREATE variable flag.
275A
RLA
Set the CARRY flag to be 0 for locate and 1 for create.
275B
LD A,C
Load register A with the number of subscripts evaluated in register C.
275C-275ELOPPTA
LD BC,000BH
Load BC with the default number of 11, which is the most entries an array can have without a DIM.
275F-2760
Jump forward to 2763H if the array is being created because it certainly wasn't found.
2761
POP BC
Get a subscript from the stack and put it in BC.
2762
INC BC
Bump the value of the subscript in BC.
2763NOTDIM
LD (HL),C
Save the LSB of the subscript's value in register C at the location of the array variables pointer in HL.
2764
INC HL
Bump the value of the array variables pointer in HL.
2765
LD (HL),B
Save the MSB of the subscript's value in register B at the location of the array variables pointer in HL.
2766
INC HL
Bump the value of the array variables pointer in HL.
2767
PUSH AF
Save the number of subscripts evaluated in register A to the stack.
2768-276A
Go multiply the size of the subscript by the value of the number type flag to determine the amount of memory necessary for the subscript.
276B
POP AF
Get the number of subscripts evaluated from the stack and put it in register A.
276C
DEC A
Check to see if there are anymore subscripts to be evaluated.
276D-276E
Jump back to 275CH if there are anymore subscripts to be evaluated.
276F
PUSH AF
Save the number of subscripts to be evaluated in register A to the stack.
2770
LD B,D
Load register B with the MSB of the array's length in register D.
2771
LD C,E
Load register C with the LSB of the array's length in register E. Now BC = length of the array in bytes.
2772
EX DE,HL
Load DE with the value of the array variables pointer in HL.
2773
ADD HL,DE
Add the length of the array in HL to the value of the array variable pointer in DE.
2774-2775
Jump back to 273DH if overflow occurred.
2776-2778
Go check to see if there is enough memory for the array.
2779-277B
LD (40FDH),HLLD (STREND),HL
Get the end of the array and put it in HL.
Note: 40FDH-40FEH holds free memory pointer.
277CZERITA
DEC HL
Decrement the value of the array pointer in HL.
277D-277E
LD (HL),00H
Zero the location of the array pointer in HL.
277F
RST 18H
Now we need to compare the array pointer in HL with the array variables pointer in DE, so we call the COMPARE DE:HL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2780-2781
Loop until the array has been cleared.
2782
INC BC
Load BC with the array's length in bytes plus one.
2783
LD D,A
Zero register D.
2784-2786
LD HL,(40D8H)LD HL,(TEMP3)
Load HL with the array variables pointer (=the number of indices).
Note: 40D8H-40D9H holds Temporary storage location.
2787
LD E,(HL)
Load register E with the number of subscripts for the array at the location of the array variables pointer in HL.
2788
EX DE,HL
Exchange the value of the array variables pointer in HL with the number of subscripts for the array in DE.
2789
ADD HL,HL
Multiply the number of subscripts for the array in HL by two.
278A
ADD HL,BC
Add the length of the array in BC to the number of subscripts times two in HL.
278B
EX DE,HL
Exchange the array's length in HL with the array variables pointer in DE.
278C
DEC HL
Decrement the value of the array variables pointer in HL.
278D
DEC HL
Decrement the value of the array variables pointer in HL.
278E
LD (HL),E
Save the LSB of the offset to the next array in register E at the location of the array variables pointer in HL.
278F
INC HL
Bump the value of the array variables pointer in HL.
2790
LD (HL),D
Save the MSB of the offset to the next array in register D at the location of the array variables pointer in HL.
2791
INC HL
Bump the value of the array variables pointer in HL.
2792
POP AF
Get the value of the locate/ create flag from the stack and put it in register A.
2793-2794
Jump forward to 27C5H if the array is being created.

AT THIS POINT [H,L] POINTS BEYOND THE SIZE TO THE NUMBER OF DIMENSIONS

2795GETDEF
LD B,A
Zero register B.
2796
LD C,A
Zero register C.
2797
LD A,(HL)
Load register A with the number of subscripts for the array at the location of the array variables pointer in HL.
2798
INC HL
Bump the value of the array variables pointer in HL.
2799
16H E1
Z-80 Trick to hide the next instruction (POP HL) if proceeding downward.
279AINLPNM
POP HL
Get the array variables pointer from the stack and put it in HL.
279B
LD E,(HL)
Load register E with the LSB of the subscript limit at the location of the array variables pointer in HL.
279C
INC HL
Bump the value of the array variables pointer in HL.
279D
LD D,(HL)
Load register D with the MSB of the subscript limit at the location of the array variables pointer in HL.
279E
INC HL
Bump the value of the array variables pointer in HL.
279F
EX (SP),HL
Exchange the value of the array variables pointer in HL with the subscript to the stack.
27A0
PUSH AF
Save the number of subscripts for the array in register A to the stack.
27A1
RST 18H
Now we need to compare the subscript limit in DE with the subscript for the array in HL, so we call the COMPARE DE:HL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
27A2-27A4
Jump back to 273DH if the subscript for the array in HL is greater than the subscript limit in DE.
27A5-27A7
Multiply the previous subscript by the subscript limit.
27A8
ADD HL,DE
Add the subscript limit for the array in DE to the array pointer in HL.
27A9
POP AF
Get the number of subscripts for the array from the stack and put it in register A.
27AA
DEC A
Check to see if there are anymore subscripts to be evaluated.
27AB
LD B,H
Load register B with the MSB of the subscript pointer in register H.
27AC
LD C,L
Load register C with the LSB of the subscript pointer in register L.
27AD-27AE
Loop back to 279AH until all of the subscripts have been evaluated.
27AF-27B1
LD A,(40AFH)LD A,(VALTYP)
Get the number type flag for the current array.
NOTE: 40AFH holds Current number type flag.
27B2
LD B,H
Load register B with the MSB of the subscript pointer in register H.
27B3
LD C,L
Load register C with the LSB of the subscript pointer in register L.
27B4
ADD HL,HL
Multiply the subscript pointer in HL by two.
27B5-27B6
SUB 04H
Check the value of the number type flag in register A.
27B7-27B8
Jump forward to 27BDH if the current number type is an integer or string.
27B9
ADD HL,HL
It isn't an integer or a string so once again multiply the subscript pointer in HL by two (so now it is multiplied by 4).
27BA-27BB
Jump forward to 27C2H if the current number type is single precision.
27BC
ADD HL,HL
It must be double precision, so once again multiply the subscript pointer in HL by two (so now it is multiplied by 8).
27BDSMLVAL
OR A
Set the flags.
27BE-27C0
Jump forward to 27C2H if the current number type isn't a string.
27C1
ADD HL,BC
The current number type is a string so add the value of the original subscript pointer in BC to the subscript pointer in HL.
27C2DONMUL
POP BC
Get the value of the array variables pointer from the stack and put it in BC.
27C3
ADD HL,BC
Add the value of the array variables pointer in BC to the subscript pointer in HL.
27C4
EX DE,HL
Load DE with the variable pointer in HL.
27C5-27C7FINNOW
LD HL,(40F3H)LD HL,(TEMP2)
Get the value of the current BASIC program pointer and put it in HL.
Note: 40F3H-40F4H holds Temporary storage location.
27C8
RET
Return.

27C9-27D3 - LEVEL II BASIC MEM Routine

This is the RETURN AMOUNT OF FREE MEMORY routine at 27C9H which computes the amount of memory remaining between the end of the variable list and the end of the stack and puts the result in REG 1 as a SINGLE PRECISION number.

27C9MEM
Zero register A and the status flags.
27CA
PUSH HL
Save the value of the current BASIC program pointer in HL to the stack.
27CB-27CD
LD (40AFH),ALD (VALTYP),A
Zero the number type flag.
NOTE: 40AFH holds Current number type flag.
27CE-27D0
GOSUB to the FRE routine at 27D4H.
27D1
POP HL
Get the value of the current BASIC program pointer from the stack and put it in HL.
27D2
RST 10H
We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
27D3
RET
Return to BASIC.

27D4-27F4 - LEVEL II BASIC FRE ROUTINE

27D4-27D6FRE
LD HL,(40FDH)LD HL,(STREND)
Load HL with the start of free memory pointer.
NOTE: 40FDH-40FEH holds Free memory pointer.
27D7
EX DE,HL
Load DE with the value of the free memory pointer in HL.
27D8-27DA
LD HL,0000H
Zero HL.
27DB
ADD HL,SP
Add the value in HL (which is zero) to the current value of the stack pointer.
27DC
RST 20H
We need to check the value of the current number type flag, so we call the TEST DATA MODE routine at RST 20H.
NOTE: The RST 20H routine determines the type of the current value in REG 1 and returns a combination of STATUS flags and unique numeric values in the A Register according to the data mode flag (40AFH).

The results are returned as follows:
If the Variable Type is ...and the Flags
are set ...		... then Register
A will be set ...
IntegerNZ/C/M/E-1
StringZ/C/P/E0
Single PrecisionNZ/C/P/O1
Double PrecisionNZ/NC/P/E5
27DD-27DE
If that test shows we do NOT have a STRING (meaning this was really a MEM call, jump to forward to 27ECH.
27DF-27E1
Get the address of the string into HL.
27E2-27E1
Go check to see how much string space remains.
27E5-27E7
LD HL,(40A0H)LD HL,(STKTOP)
Load HL with the start of string space pointer.
NOTE: 40A0H-40A1H holds the start of string space pointer.
27E8
EX DE,HL
Load DE with the start of string space pointer in HL.
27E9-27EB
LD HL,(40D6H)LD HL,(FRETOP)
Load HL with the next available location in string space pointer.
NOTE: 40D6H-40D7H holds Next available location in string space pointer.

This routine subtracts [D,E] from [H,L] and floats the result leaving it in FAC.

27ECGIVDBL
LD A,L
Load register A with the LSB of the next available location in string space pointer in register L.
27ED
SUB E
Subtract the LSB of the start of string space pointer in register E from the LSB of the next available location in string space pointer in register A.
27EE
LD L,A
Load register L with the LSB of the amount of string space remaining in register A.
27EF
LD A,H
Load register A with the MSB of the next available location in string space pointer in register H.
27F0
SBC A,D
Subtract the MSB of the string space pointer in register D from the MSB of the next available location of string space pointer in register A.
27F1
LD H,A
Load register H with the MSB of the amount of string space remaining in register A.
27F2-27F4
Jump to 0C66H to convert the difference between HL and DE to single precision and then RETurn out of the routine.

27F5-27FD - LEVEL II BASIC POS( ROUTINE

27F5-27F7POS
LD A,(40A6H)LD A,(TTYPOS)
Load register A with the current cursor line position.
Note: 40A6H holds the current cursor line position.
27F8SNGFLT
LD L,A
Load register L with the value of the current cursor line position in register A.
27F9
XOR A
Zero register A.
27FAGIVINT
LD H,A
Load register H with zero, so now HL is 00 / cursor position.
27FB-27FD
Jump to 0A9AH.

27FE-2818 - LEVEL II BASIC USR(x) ROUTINE

27FE-2800USRFN
Go call the DOS link at 41A9H.
2801
RST 10H
We need the next character so call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2802-2804
GOSUB to 252CH to evaluate the expression at the location of the current BASIC program pointer in HL and return with the result in REG 1.
2805
PUSH HL
Save the value of the current BASIC program pointer in HL (=the address of the next element in the code string) to the stack.
2806-2808
LD HL,0890H
Load HL with the return address of 0890H which will clear the stack before returning to BASIC.
2809
PUSH HL
Save the value of the return address in HL to the stack.
280A-280C
LD A,(40AFH)LD A,(VALTYP)
Load register A with the value of the current number type flag.
Note: 40AFH holds Current number type flag.
280D
PUSH AF
Save the value of the current number type flag in register A.
(02=INT, 03=STR, 04=SNG, 08=DBL).
280E-280F
CP 03H
Check to see if the current value in REG l is a string.
2810-2812
If the current result in REG l is a string then GOSUB to 29DAH to get the string address into HL.
2813
POP AF
Restore the number type flag into register A.
2814
EX DE,HL
Load DE with the value of the string address in HL.
2815-2817
LD HL,(408EH)LD HL,(USRTAB)
Load HL with the starting address of the machine language subroutine.
  • Note: 408EH-408FH holds the entry address of a machine language program to be called by a USR command.
2818
JP (HL)
Jump to the address in HL.

2819-2827 - CONVERSION ROUTINE
Usually called by LET to convert the result of arithmetic routines to the proper destination type

2819DOCNVF
PUSH HL
Save the value in HL to the stack.
281A-281B
AND 07H
Mask the value of the current number type flag in register A.
281C-281E
LD HL,18A1HLD HL,FRCTBL
Load HL with the address of the arithmetic conversion routines.
281F
LD C,A
Load register C with the value of the number type flag in register A.
(02=INT, 03=STR, 04=SNG, 08=DBL).
2820-2821
LD B,00H
Zero register B. Now BC holds 00 / type.
2822
ADD HL,BC
Add the offset (of BC) to the base arithmetic conversion routines, to find the right jump point.
2823-2825
GOSUB to 2586H to convert the current result in REG l to its proper number type.
2826
POP HL
Get the value from the stack and put it in HL.
2827
RET
Return.

2828-2835 - Save the code string address
Usually called from the INPUT routine. On entry HL has the current line number in binary.

2828ERRDIR
PUSH HL
Save the value of the current BASIC program pointer in HL to the stack.
2829-282B
LD HL,(40A2H)LD HL,(CURLIN)
Load HL with the value of the current BASIC line number.
NOTE:40A2H-40A3H holds the current BASIC line number.
282C
INC HL
Bump the value of the current BASIC line number in HL to enable us to test for a direct statement.
282D
LD A,H
Load register A with the MSB of the current BASIC line number in register H.
282E
OR L
Combine the LSB of the current BASIC line number in register L with the MSB of the current BASIC line number in register A.
282F
POP HL
Get the value of the current BASIC program pointer from the stack and put it in HL.
2830
RET NZ
Return if there is a line number (i.e., this isn't the command mode).

2831 - ID ERROR entry point.

2831-2832
LD E,16HLD E,ERRID
Load register E with the ?ID ERROR code.
2833-2835
Display an ?ID ERROR if this is the command mode.

2836-2856 - LEVEL II BASIC STR$ ROUTINE

2836-2838STR$
GOSUB to 0FBDH to convert the current result in REG 1 to an ASCII string.
2839-283BSTR$1
Go make a temporary string work area entry.
283C-283E
Load HL with the string's VARPTR.
283F-2841
LD BC,2A2BHLD B,FINBCK
Load BC with a return address of 2A2BH (which cleans the stack and then jumps to 2884H).
2842
PUSH BC
Save the value of the return address in BC to the stack.

STRCPY creates a copy of the string whose descriptor is pointed to by [H,L].
On return [D,E] points to DSCTMP which has the string info (length, where copied to)

2843STRCPY
LD A,(HL)
Load register A with the string's length at the location of the string's VARPTR in HL.
2844
INC HL
Bump the value of the string's VARPTR in HL.
2845
PUSH HL
Save the value of the string's VARPTR in HL to the stack.
2846-2848
GOSUB to 28BFH to test the remaining string area to make sure that the new string will fit.
2849
POP HL
Reload HL with the string's VARPTR.
284A
LD C,(HL)
Load register C with the LSB of the string's address at the location of the string's VARPTR in HL.
284B
INC HL
Bump the value of the string's VARPTR in HL.
284C
LD B,(HL)
Load register B with the MSB of the string's address at the location of the string's VARPTR in HL.
284D-284F
GOSUB to 285AH to save the string's length and the string's address at 40D3H.
2850
Save the value in HL (which is 40D3H) to the stack.
2851
LD L,A
Load register L with the string's length (from register A).
2852-2854
GOSUB to 29CEH to move the string from the temp area (of BC) to the string data area (in DE).
2855
POP DE
Get the value from the stack (40D3H) and put it in DE.
2856
RET
Return.

2857-2864 - STRING ROUTINE - Set Up a String. A needs to hold the length of the string to be created

2857-2859STRINI
GOSUB to 28BFH to make sure that there is enough string space remaining for the string. Get the address of the next string area in DE. Then save A and DE at 40D3H-40D5H.
285A-285CSTRAD2
LD HL,40D3HLD HL,DSCTMP
Load HL with the address of the temporary string parameter storage area.
Note: 40D3H-40D5H holds Used for temporary string VARPTR's.
285DSTRAD1
PUSH HL
Save the address of the temporary string parameter area in HL to the stack.
285E
LD (HL),A
Save the string's length in register A at the location of the temporary string parameter storage pointer in HL.
285FPUTDEI
INC HL
Bump the value of the temporary string parameter storage pointer in HL.
2860
LD (HL),E
Save the LSB of the string's address in register E at the location of the temporary string parameter storage pointer in HL.
2861
INC HL
Bump the value of the temporary string parameter storage pointer in HL.
2862
LD (HL),D
Save the MSB of the string's address in register D at the location of the temporary string parameter storage pointer in HL.
2863
POP HL
Get the address of the temporary string parameter storage area from the stack and put it in HL.
2864
RET
Return.

2865-28A5 - STRING ROUTINE

This is the quote routine. C will be a counter.

STRLT2 takes the string literal whose first character is pointed by [H,L]+1 and builds a descriptor for it.
The descriptor is initially built in DSCTMP, but PUTNEW transfers it into a temporary and leaves a pointer at the temporary in FACLO.
The characters other than zero that terminate the string should be set up in [B] and [D].
It the terminator is a quote, the quote is skipped over.
Leading quotes should be skipped before call.
On return the character after the string literal is pointed to by [H,L] and is in [A], but the condition codes are not set up.

2865HSTRLIT
DEC HL
Decrement the value of the current BASIC program pointer in HL.
2866-2867STRLTI
LD B,22H
Load register B with a " (which is really the opening search character).
2868STRLT3
LD D,B
Load register D with a " (which is really the ending search character).
2869STRLT2
PUSH HL
Save the address of the current BASIC program pointer in HL to the stack.
286A-286B
LD C,0FFH
Load register C with a -1.
286CSTRGET
INC HL
Bump the value of the current BASIC program pointer in HL to skip over that initial ".
286D
LD A,(HL)
Load register A with the character at the location of the current BASIC program pointer in HL.
286E
INC C
Bump the counter in register C.
286F
OR A
Check to see if the character at the location of the current BASIC program pointer in register A is an end of the BASIC line character.
2870-2871
Jump to 2878H if the character at the location of the current BASIC program pointer in register A is an end of the BASIC line character.
2872
CP D
Check to see if the character at the location of the current BASIC program pointer in register A is the same as the terminating character in register D.
2873-2874
Jump to 2878H if the character at the location of the current BASIC program pointer in register A is the same as the terminating character in register D.
2875
CP B
Check to see if the character at the location of the current BASIC program point.er in register A is the same at the terminating character in register B.
2876-2877
Loop back to 286CH if the character at the location of the current BASIC program pointer in register A isn't the same as the terminating character in register B.
2878-2879STRFIN
CP 22H
Check to see if the character at the location of the current BASIC program pointer in register A is a quote.
287A-287C
If it was a quote, then GOSUB to 1D78H to bump the value of the current BASIC program pointer in HL until it points to the next character.
287D
EX (SP),HL
Exchange the value of the current BASIC program pointer in HL with the string's address to the stack.
287E
INC HL
Bump the string's address in HL until it points to the first character of the string.
287F
EX DE,HL
Load DE with the string's address in HL.
2880
LD A,C
Load register A with the string's length from register C.
2881-2883
GOSUB to 285AH to save the string's length and the string's address into 40D3H.

Some string function is returning a result in DSCTMP.
We want to setup a temp descriptor with DCSTMP in it, put a pointer to the descriptor in FACLO and flag the result as type string

2884-2886PUTNEW
LD DE,40D3HLD DE,DSCTMP
Load DE with the address of the string parameter storage area.
Note: 40D3H-40D5H holds Used for temporary string VARPTR's.
2887-2888
LD A,D5H
This is a Z-80 Trick to skip the next instruction if it is a pass through.
2888PUTTMP
PUSH DE
Save a pointer to the start of the string.
2889-288B
LD HL,(40B3H)LD HL,(TEMPPT)
Load HL with the next available location in the temporary string work area in HL as the string's VARPTR in REG 1.
Note: 40B3H-40B4H holds Next available location in the temporary string work area pointer.
288C-288E
LD (4121H),HLLD (FACLO),HL
Save the value of the next available location in the temporary string work area in HL as the string's VARPTR in REG 1.
288F-2890
LD A,03H
Load register A with the string number type flag.
2891-2893
LD (40AFH),ALD (VALTYP),A
Save the value in register A as the current number type flag.
Note: 40AFH holds Current number type flag.
2894-2896
Add the length of the string to the next available location in the temporary string work area in HL.
2897-2899
LD DE,40D6HLD DE,DSCTMP+3
Load DE with the ending address of the temporary string work area.
Note: 40D6H-40D7H holds Next available location in string space pointer.
289A
RST 18H
Now we need to check to see if the updated temporary string work area location in HL isn't greater than the ending address of the temporary string work area in DE, so we call the COMPARE DE:HL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
289B-289D
LD (40B3H),HLLD (TEMPPT),HL
Save the updated string work area location in HL as the next available location in the temporary string work area.
Note: 40B3H-40B4H holds Next available location in the temporary string work area pointer.
289E
POP HL
Get the value of the current BASIC program pointer from the stack and put it in HL.
289F
LD A,(HL)
Load register A with the character at the location of the current BASIC program pointer in HL.
28A0
RET NZ
Return if the updated temporary string work area location wasn't beyond the end of the temporary string work area (meaning it overflowed, because if it overflowed ...).

28A1 - ST ERROR entry point.

28A1-28A2STERR
LD E,1EHLD E,ERRST
Load register E with a ?ST ERROR code.
28A3-28A5
Display a ?ST ERROR message if the temporary string work area has overflowed.

28A6-28BE - DISPLAY MESSAGE ROUTINE

Print the string pointed to by [H,L] which ends with a zero.
If the string is below DSCTMP it will be copied into string space

28A6STROUI
INC HL
Bump the value of the current BASIC program pointer in HL.

28A7 - This is a general purpose output routine.

It will output data to the display, printer or cassette, depending on the contents of 409CH. (0=video, -1=tape, 1=printer). The address of the first character in the string to be output must be in the HL register pair, and the string must end with a zero byte or a quote (22H).
Note: 409CH holds the current output device flag: -1=cassette, 0=video and 1=printer.
This is the WRITE MESSAGE routine, which displays message pointed to by HL on current system output device (usually video). The string to be displayed must be terminated by a byte of machine zeros or a carriage return code 0D. If terminated with a carriage return, control is returned to the caller after taking the DOS exit at 41D0 (JP 5B99H). This subroutine uses th literal string pool table and the string area. It should not be called if the communications region and the string area are not properly maintained.


This routine has essentially the same effect as the routine at 2B75H, except that text may also end with a quotation mark (22H), creates string vector before output (destroys current contents of ACCUM, sets number type flag at 40AFH to 3 - see chapter two of this book), and also uses BC & DE registers. Depends heavily on BASIC string management routines (use of 2B75H or other routines may be preferable). If string contains a carriage return (ODH) character, a CALL will be made to the Disk BASIC link at 41DOH. Used by BASIC PRINT statement. This routine may also be entered at 28A6H, in which case the HL register pair will be incremented prior to beginning to output string.

To use a ROM call to display a string of characters starting at the current cursor position, and to update the cursor position,store the characters in consecutive memory locations, with a zero byte at the end, then load the HL register pair with the address of the first character of the string, and then CALL 28A7CALL STROUTH.

EXAMPLE: Suppose that we have the following symbolic setup:
TITL DEFM 'INSIDE LEVEL II'
DEFB 0
Then, the instructions:
LD HL,TITL
CALL 28A7CALL STROUTH
will cause "INSIDE LEVEL II" to be displayed at the current cursor position and the cursor position to be updated.

NOTE: If the subroutine at 28A7H is used by an assembly language program that is itself entered by a USR call, the return from the assembly language program may encounter the embarrassment of a TM error, with control passing to the Level II monitor. This occurs because the subroutine at 28A7H leaves a 3 in location 40AFH, while the USR structure requires a 2 in 40AFH upon returning. The malady is cured by storing a 2 in 40AFH before returning, or by jumping to 0A9AH instead of executing the simple RET. The problem would not occur in the first place if the assembly language program returns the value of an integer variable to the BASIC program, and it might not occur if some other ROM routine is called after the subroutine at 28A7H and before returning ? if the other subroutine produces an integer output. DISK SYSTEM CAUTION: See the DISK SYSTEM CAUTION of Section 8.1 regarding the exits to DISK BASIC from the subroutine at 28A7H.

28A7-28A9HSTROUT
Go build a temporary string work area entry for the message at the location of the current BASIC program pointer in HL.
28AA-28ACSTRPRT
GOSUB to 29DAH to load HL with the string's VARPTR.
28AD-28AF
Go get the string's length in register D and the string's address in BC.
28B0
INC D
Bump the value of the string's length in register D in preparation for the following loop which starts with a DEC D.
28B1STRPR2
DEC D
Decrement the value of the string's length in register D.
28B2
RET Z
Return if all of the characters in the string have been sent to the current output device.
28B3
LD A,(BC)
Load register A with the character at the location of the string pointer in BC.
28B4-28B6
Go send the character in register A to the current output device.
28B7-28B8
CP 0DH
Check to see if the character in register A is a carriage return.
28B9-28BB
Jump to 2103H if the character in register A is a carriage return.
28BC
INC BC
Bump the value of the string pointer in BC.
28BD-28BE
Loop until all of the characters in the string have been sent to the current output device.

28BF-28D9 - STRING ROUTINE - Compute the amount of space remaining in the string area.

GETSPA - get space for character string.
May force garbage collection.
# of chars (bytes) in [A].
Returns with pointer in [D,E] otherwise if cant get space blows off to "out of string space" type error.

28BFGETSPA
OR A
Set the flags.
28C0-28C1
0E F1
Z-80 Trick.
28C1TRYGI2
POP AF
Get the string's length from the stack and put it in register A.
28C2
PUSH AF
Save the length of the string in register A to the stack.
28C3-28C5
LD HL,(40A0H)LD HL,(STKTOP)
Load HL with the start of the string space pointer.
Note: 40A0H-40A1H holds the start of string space pointer.
28C6
EX DE,HL
Move the start of the string space pointer into DE. We don't care what happens to HL.
28C7-28C9
LD HL,(40D6H)LD HL,(FRETOP)
Load HL with the next available location in string space pointer.
Note: 40D6H-40D7H holds Next available location in string space pointer.
28CA
CPL
Complement the string's length in register A so that it is negative.
28CB
LD C,A
Load register C with the negative string's length in register A.
28CC-28CD
LD B,0FFH
Load register B with a -1 so that BC will be the negative length of the string.
28CE
ADD HL,BC
Add the negative string's length in BC to the next available location in string space pointer in HL.
28CF
INC HL
Bump the value of the adjusted next available location in string space pointer in HL.
28D0
RST 18H
Now we need to check to see if the adjusted next available location in string space pointer in HL is less than the start of string space pointer in DE, so we call the COMPARE DE:HL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
28D1-28D2
Jump forward to 28DAH if the adjusted next available location in string space pointer in HL is less than the start of string space pointer in DE.
28D3-28D5
LD (40D6H),HLLD (FRETOP),HL
Save the value in HL as the next available location in string space pointer.
Note: 40D6H-40D7H holds Next available location in string space pointer.
28D6
INC HL
Bump the value of the next available location in string space pointer in HL.
28D7
EX DE,HL
Load DE with the next available location in string space pointer in HL.
28D8PPSWRT
POP AF
Get the string's length from the stack and put it in register A.
28D9
RET
Return.

28DA-298E - STRING ROUTINE

28DAGARBAG
POP AF
Get the length of the string from the stack and put it in register A. This also gets the status flag to help us find out if reorganization has already been attempted.
28DB-28DC
LD E,1AHLD E,ERRSO
Load register E with an ?OS ERROR code.
28DD-28DF
Display a ?OS ERROR if there isn't enough string space available for the string and we had already reorganized string space.
28E0
CP A
Set the flags.
28El
PUSH AF
Save the string's length in register A to the stack.
28E2-28E4
LD BC,28C1HLD B,TRYGI2
Load BC with a return address of 28C1H (which would retry allocation).
28E5
PUSH BC
Save that return address to the stack.
28E6-28E8GARBA2
LD HL,(40B1H)LD HL,(MEMSIZ)
Load HL with the top of memory pointer.
Note: 40B1H-40B2H holds MEMORY SIZE? pointer.
28E9-28EBFNDVAR
LD (40D6H),HLLD (FRETOP),HL
Save the top of BASIC memory pointer in HL as the next available location in string space pointer.
Note: 40D6H-40D7H holds Next available location in string space pointer.
28EC-28EE
LD HL,0000H
Zero HL.
28EF
PUSH HL
Save the value in HL to the stack.
28F0-28F2
LD HL,(40A0H)LD HL,(STKTOP)
Load HL with the start of string space pointer.
NOTE: 40A0H-40A1H holds the start of string space pointer.
28F3
PUSH HL
Save the start of string space pointer in HL to the stack.
28F4-28F6
LD HL,40B5HLD HL,TEMPST
Load HL with the start of the temporary string work area pointer.
Note: 40B5H-40D2H holds Temporary string work area.
28F7TVAR
EX DE,HL
Load DE with the start of the temporary string work area pointer in HL.
28F8-28FA
LD HL,(40B3H)LD HL,(TEMPPT)
Load HL with the next available location in the temporary string work area pointer.
NOTE: 40B3H-40B4H holds Next available location in the temporary string work area pointer.
28FB
EX DE,HL
Exchange the start of the temporary string work area pointer in DE with the next available location in the temporary string work area pointer in HL.
28FC
We need to see if 40B3H is pointing to the first entry (40B5H) - if the start of the temporary string work area pointer in HL is the same as the next available location in the temporary string work area pointer, so we call the COMPARE DE:HL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
28FD-28FF
LD BC,28F7HLD B,TVAR
Load BC with a return address of 28F7H.
2900-2902
Jump to 294AH if the temporary string work area isn't empty.
2903SVARS
LD HL,(40F9H)LD HL,(VARTAB)
Load HL with the start of the simple variables pointer.
NOTE: 40F9H-40FAH holds the starting address of the simple variable storage area.
2906SVAR
EX DE,HL
Load DE with the simple variables pointer in HL.
2907-2909
LD HL,(40FBH)LD HL,(ARYTAB)
Load HL with the start of the array variables pointer.
  • Note: 40FBH-40FCH holds the starting address of the BASIC array variable storage area.
290A
EX DE,HL
Exchange the value of the simple variables pointer in DE with the value of the array variables pointer in HL.
290B
RST 18H
Now we need to check to see if the simple variables pointer in HL is the same as the array variables pointer in DE, so we call the COMPARE DE:HL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
290C-290D
Jump forward to 2921H if the simple variables pointer in HL is the same as the array variables pointer in DE.
290E
LD A,(HL)
Load register A with the number type flag at the location of the simple variables pointer in HL.
290F
INC HL
Bump the value of the simple variables pointer in HL.
2910
INC HL
Bump the simple variables pointer in HL.
2911
INC HL
Bump the value of the simple variables pointer in HL.
2912-2913
CP 03H
Check to see if the variable at the location of the simple variables pointer is a string.
2914-2915
Jump to 291AH if the variable at the location of the simple variables pointer in HL isn't a string.
2916-2918
GOSUB to 294BH to do string check.
2919
XOR A
Zero register A.
291ASKPVAR
LD E,A
Zero register E.
291B-291C
LD D,00H
Zero register D.
29lD
ADD HL,DE
Add the value of the number type flag in DE to the simple variables pointer in HL.
291E-291F
Loop back to 2906H until all of the simple variables have been checked.
2920ARYVA2
POP BC
Clean up the stack.
2921ARYVAR
EX DE,HL
Load DE with the value of the array variables pointer in HL.
2922-2924
LD HL,(40FDH)LD HL,(STREND)
Load HL with the start of free memory pointer.
Note: 40FDH-40FEH holds Free memory pointer.
2925
EX DE,HL
Exchange the value of the array variables pointer in DE with the value of the free memory pointer in HL.
2926
RST 18H
Now we need to check to see if the array variables pointer in HL is the same as the free memory pointer in DE, so we call the COMPARE DE:HL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2927-2929
Jump if the array variables pointer in register HL is the same as the start of the free memory pointer in DE.
292A
LD A,(HL)
Load register A with the number type flag at the location of the array variables pointer in HL.
292B
INC HL
Bump the value of the array variables pointer in HL.
292C-292E
CALL 09C2HCALL MOVRM (which loads a SINGLE PRECISION value pointed to by HL into register pairs BC and DE).
292F
PUSH HL
Save the value of the array variables pointer in reg? ister pair HL to the stack.
2930
ADD HL,BC
Add the value of the offset to the next array in BC to the value of the array variables pointer in HL.
2931-2932
CP 03H
Check to see if the array being examined is a string.
2933-2934
Jump if the array being examined isn't a string.
2935-2937
LD (40D8H),HLLD (TEMP3),HL
Save the address of the next array in HL.
Note: 40D8H-40D9H holds Temporary storage location.
2938
POP HL
Get the value of the array variables pointer from the stack and put it in HL.
2939
LD C,(HL)
Load register C with the number of subscripts for the array at the location of the array variables pointer in HL.
293A-293B
LD B,00H
Zero register B.
293C
ADD HL,BC
Add the number of subscripts in the array in BC to the value of the array variables pointer in HL.
293D
ADD HL,BC
Add the number of subscripts in the array in BC to the value of the array variables pointer in HL.
293E
INC HL
Bump the value of the array variables pointer in HL.
293FARYSTR
EX DE,HL
Load DE with the value of the array variables pointer in HL.
2940-2942
LD HL,(40D8H)LD HL,(TEMP3)
Load HL with the address of the next array.
Note: 40D8H-40D9H holds Temporary storage location.
2943
EX DE,HL
Exchange the value of the array variables pointer in DE with the address of the array in HL.
2944
RST 18H
Now we need to check to see if the array variables pointer in HL is the same as the address of the next array in DE, so we call the COMPARE DE:HL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2945-2946
Jump to 2921H if the array variables pointer in HL is the same as the address of the next array in DE.
2947-2948
LD BC,293FHLD B,ARYSTR
Load BC with a return address of 293FH.
294ADVAR2
PUSH BC
Save the value in BC to the stack.
294BDVAR/DVARS
XOR A
Zero register A.
294C
OR (HL)
Load register A with the length of the string at the location of the array variables pointer in HL.
294D
INC HL
Bump the value of the array variables pointer in HL.
294E
LD E,(HL)
Load register E with the LSB of the string's address at the location of the array variables pointer in HL.
294F
INC HL
Bump the value of the array variables pointer in HL.
2950
LD D,(HL)
Load register D with the MSB of the string's address at the location of the array variables pointer in HL.
2951
INC HL
Bump the value of the array variables pointer in HL.
2952
RET Z
Return if the string's length in register A is equal to zero.
2953
LD B,H
Load register B with the MSB of the array variables pointer in register H.
2954
LD C,L
Load register C with the LSB of the array variables pointer in register L.
2955-2957
LD HL,(40D6H)LD HL,(FRETOP)
Load HL with the location of the next available location in string space pointer.
NOTE: 40D6H-40D7H holds Next available location in string space pointer.
2958
RST 18H
Now we need to check to see if the string's address in DE is in string space, so we call the COMPARE DE:HL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2959
LD H,B
Load register H with the MSB of the array variables pointer in register B.
295A
LD L,C
Load register L with the LSB of the array variables pointer in register C.
295B
RET C
Return if the string's address in DE is in string space.
295C
POP HL
Get the return address from the stack and put it in HL.
295D
EX (SP),HL
Exchange the value of the return address in HL with the start of string space pointer to the stack.
295E
RST 18H
Now we need to check to see if the string's address in DE is below the start of string space pointer in HL, so we call the COMPARE DE:HL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
295F
EX (SP),HL
Exchange the start of string space pointer in HL with the value of the return address to the stack.
2960
PUSH HL
Save the value of the return address in HL to the stack.
2961
LD H,B
Load register H with the MSB of the array variables pointer in register B.
2962
LD L,C
Load register L with the LSB of the array variables pointer in register C.
2963
RET NC
Return if the string's address in DE is below the string space pointer.
2964
POP BC
Get the return address from the stack and put it in BC.
2965
POP AF
Clean up the stack.
2966
POP AF
Clean up the stack.
2967
PUSH HL
Save the value of the array variables pointer in HL to the stack.
2968
PUSH DE
Save the string's address in DE to the stack.
2969
PUSH BC
Save the value of the return address in BC to the stack.
296A
RET
Return.

Here when made one complete pass thru string vars

296BGRBPAS
POP DE
Load DE with the address of the last string put into the temporary string work area.
296C
POP HL
Get the temporary string work area pointer from the stack and put it in HL.
296D
LD A,L
Load register A with the LSB of the temporary string work area pointer in register L.
296E
OR H
Combine the MSB of the temporary string work area pointer in register H with the LSB of the temporary string work area pointer in register A.
296F
RET Z
Return if the temporary string work area is empty.
2970
DEC HL
Decrement the value of the temporary string work area pointer in HL.
2971
LD B,(HL)
Load register B with the MSB of the string's address at the location of the temporary string work area pointer in HL.
2972
DEC HL
Decrement the value of the temporary string work area pointer in HL.
2973
LD C,(HL)
Load register C with the LSB of the string's address at the location of the temporary string work area pointer in HL.
2974
PUSH HL
Save the value of the temporary string work area pointer in HL to the stack.
2975
DEC HL
Decrement the value of the temporary string work area pointer in HL.
2976
LD L,(HL)
Load register L with the string's length at the location of the temporary string work area pointer in HL.
2977-2978
LD H,00H
Zero register H.
2979
ADD HL,BC
Add the length of the string in HL to the string's address in BC.
297A
LD D,B
Load register D with the MSB of the string's address in register B.
297B
LD E,C
Load register E with the LSB of the string's address in register C.
297C
DEC HL
Decrement the value of the string's ending address in HL.
297D
LD B,H
Load register B with the MSB of the string's ending address in register H.
297E
LD C,L
Load register C with the LSB of the string's ending address in register L.
297F-2981
LD HL,(40D6H)LD HL,(FRETOP)
Load HL with the next available location in string space pointer.
NOTE: 40D6H-40D7H holds Next available location in string space pointer.
2982-2984
Move the string from the temporary storage location to string space.
2985
POP HL
Get the temporary string work area pointer from the stack and put it in HL.
2986
LD (HL),C
Save the LSB of the string's address in register Cat the location of the temporary string work area pointer in HL.
2987
INC HL
Bump the value of the temporary string work area pointer in HL.
2988
LD (HL),B
Save the MSB of the string's address in register B at the location of the temporary string work area pointer in HL.
2989
LD L,C
Load register L with the LSB of the string's address in register C.
298A
LD H,B
Load register H with the MSB of the string's address in register B.
298B
DEC HL
Decrement the string's address in HL.
298C-298E
Jump to 28E9H.

298F-29C5 - STRING ADDITION ROUTINE - Concatenate two strings

The following routine concatenates two strings.
The FACLO contains the first one at this point, [H,L] points beyond the + sign after it

298FCAT
PUSH BC
Save the operator value in BC to the stack.
2990
PUSH HL
Save the value of the current BASIC program pointer in HL to the stack.
2991-2993
LD HL,(4121H)LD HL,(FACLO)
Load HL with the first string's VARPTR (from REG 1).
2994
EX (SP),HL
Exchange the value of the first string's VARPTR in HL with the value of the current BASIC program to the stack.
2995-2997
GOSUB to 249FH to evaluate the expression at the location of the current BASIC program pointer in HL.
2998
EX (SP),HL
Exchange the value of the current BASIC program pointer in HL with the value of the first string's VARPTR to the stack.
2999-299B
Go make sure the current result in REG 1 is a string.
299C
LD A,(HL)
Load register A with the first string's length at the location of the first string's VARPTR in HL.
299D
PUSH HL
Save the value of the first string's VARPTR in HL to the stack.
299E-29A0
LD HL,(4121H)LD HL,(FACLO)
Load HL with the second string's VARPTR in REG 1.
29A1
PUSH HL
Save the second string's VARPTR in HL to the stack.
29A2
ADD A,(HL)
Add the length of the second string at the location of the second string's VARPTR in HL to the length of the first string in register A.
29A3-29A4
LD E,1CH
Load register E with a ?LS ERROR code.
29A5-29A7
Display a ?LS ERROR message if the combined lengths of the strings is greater than 255.
29A8-29AA
Go make sure that there is enough string space for the new string.
29AB
POP DE
Get the second string's VARPTR from the stack and put it in DE.
29AC-29AE
Go update the temporary string work area.
29AF
EX (SP),HL
Exchange the second string's VARPTR in HL with the first string's VARPTR to the stack.
29B0-29B2
Go update the temporary string work area.
29B3
PUSH HL
Save the value of the first string's VARPTR in HL to the stack.
29B4-29B6INCSTR
LD HL,(40D4H)LD HL,(DSCTMP+INCSTR)
Load HL with the second string's address.
29B7
EX DE,HL
Load DE with the second string's address in HL.
29B8-29BA
Go move the first string to its temporary storage location.
29BB-29BD
Go move the second string to its temporary storage location.
29BE-29C0
LD HL,2349H
Load HL with the return address.
29C1
EX (SP),HL
Exchange the value of the return address in HL with the value of the current BASIC program pointer to the stack.
29C2
PUSH HL
Save the value of the current BASIC program pointer in HL to the stack.
29C3-29C5
Jump to 2884H.

29C6-29D6 - STRING ROUTINE - This will move strings using the stack

On entry, the stack should have the count/source address and DE should have the destination address.

29C6MOVINS
POP HL
Load HL with the value of the return address to the stack.
29C7
EX (SP),HL
Exchange the value of the return address in HL with the string's VARPTR to the stack.

29C8 - STRING MOVE ROUTINE
On entry HL points to the string control block for the string to be moved, and DE contains the destination address. All registers are used. The string length and address are not moved. String control blocks have the format: X=String Length; ADDR = String Address.

29C8
LD A,(HL)
Load register A with the string's length at the location of the string's VARPTR in HL.
29C9
INC HL
Bump the value of the string's VARPTR in HL.
29CA
LD C,(HL)
Load register C with the LSB of the string's address at the location of the string's VARPTR in HL.
29CB
INC HL
Bump the value of the string's VARPTR in HL.
29CC
LD B,(HL)
Load register B with the MSB of the string's address at the location of the string's VARPTR in HL.
29CD
LD L,A
Load register L with the string's length in register A.
29CEMOVSTR
INC L
Bump the value of the string's length in register L.
29CFMOVLP
DEC L
Decrement the value of the string's length in register L.
29D0
RET Z
Return if all of the characters in the string have been moved.
29D1
LD A,(BC)
Load register A with the character at the location of the string pointer in BC.
29D2
LD (DE),A
Save the character in register A at the location of the string storage pointer in DE.
29D3
INC BC
Bump the value of the string pointer in BC.
29D4
INC DE
Bump the value of the string storage pointer in DE.
29D5-29D6
Loop until the string has been completely moved.

29D7-29F4 - FREE UP STRING TEMPORARY - FRESTR, FREFAC, FRETMP, FRETMS

FRETMP is passed a pointer to a string descriptor in [D,E].
This value is returned in [H,L].
All the other registers are modified.
A check to is made to see if the string descriptor [D,E] points to is the last temporary descriptor allocated by PUTNEW.
If so, the temporary is freed up by the updating of TEMPPT.
If a temporary is freed up, a further check is made to see if the string data that that string temporary pointed to is the the lowest part of string space in use.
If so, FRETMP is updated to reflect the fact that that space is no longer in use.

This routine is a contination of VAL, FRE, and PRINT processing. A jump to here would include the need to get a string's VARPTR and put it in HL.

29D7-29D9FRESTR
GOSUB to 0AF4H to make sure that the current result in REG l is a string.
29DA-29DCFREFAC
LD HL,(4121H)LD HL,(FACLO)
Load HL with the string's VARPTR in REG 1.
29DDFRETM2
EX DE,HL
Load DE with the value of the string's VARPTR in HL.
29DE-29E0FRETMP
Check to see if the string is the last entry in the temporary string work area.
29E1
EX DE,HL
Load HL with the value of the string's VARPTR in DE.
29E2
RET NZ
Return if the string isn't the last entry in the temporary string work area.
29E3
PUSH DE
Save the value of the string's VARPTR in DE to the stack.
29E4
LD D,B
Load register D with the MSB of the string's address in register B.
29E5
LD E,C
Load register E with the LSB of the string's address in register C.
29E6
DEC DE
Decrement the value of the string's address in DE.
29E7
LD C,(HL)
Load register C with the string's length at the location of the string's VARPTR in HL.
29E8-29EA
LD HL,(40D6H)LD HL,(FRETOP)
Load HL with the next available location in string space pointer.
Note: 40D6H-40D7H holds Next available location in string space pointer.
29EB
RST 18H
We need to see if the current string is the last one defined in the string area by seeing if the string's address in DE is the same as the next available location in string space pointer in HL, so we call the COMPARE DE:HL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
29EC-29ED
Jump forward to 29F3H if the string's address in DE isn't the same as the next available location in string space pointer in HL.
29EE
LD B,A
If is the last one defined then we need to update the current string pointer so first we load register B with the value in register A.
29EF
ADD HL,BC
Add the length of the string in BC to the next available location in string space pointer in HL.
29E0-29F2
LD (40D6H),HLLD (FRETOP),HL
Save the adjusted next available location in string space pointer in HL.
Note: 40D6H-40D7H holds Next available location in string space pointer.
29F3NOTLST
POP HL
Get the string's VARPTR from the stack and put it in HL.
29F4
RET
Return.

29F5-2A02 - STRING ROUTINE

29F5-29F7FRETMS
LD HL,(40B3H)LD HL,(TEMPPT)
Load HL with the temporary string work area pointer.
Note: 40B3H-40B4H holds Next available location in the temporary string work area pointer.
29F8
DEC HL
Decrement the value of the temporary string work area pointer in HL which backs up two words.
29F9
LD B,(HL)
Load register B with the MSB of the string's address at the location of the temporary string work area pointer in HL.
29FA
DEC HL
Decrement the value of the temporary string work area pointer in HL.
29FB
LD C,(HL)
Load register C with the LSB of the string's address at the location of the temporary string work area pointer in HL.
29FC
DEC HL
Decrement the value of the temporary string work area pointer in HL.
29FD
RST 18H
Now we need to check to see if the string's VARPTR in DE matches the temporary string work area pointer in HL, so we call the COMPARE DE:HL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
29FE
RET NZ
Return if the string's VARPTR in DE doesn't match the temporary string work area pointer in HL.
29FF-2A01
LD (40B3H),HLLD (TEMPPT),HL
Save the value of the temporary string work area pointer in HL.
Note: 40B3H-40B4H holds Next available location in the temporary string work area pointer.
2A02
RET
Return.

2A03-2A0E - LEVEL II BASIC "LEN" ROUTINE

The function LEN($) returns the length of the string passed as an argument

2A03-2A05LEN
LD BC,27F8HLD BC,SNGFLT
Load BC with the return address of 27F8H.
2A06
Save the return address of 27F8H (in BC) to the stack.
2A07-2A09LEN1
GOSUB to 29D7H to get the string's VARPTR and put it in HL.
2A0A
XOR A
Zero register A.
2A0B
LD D,A
Zero register D.
2A0C
LD A,(HL)
Load register A with the string's length at the location of the string's VARPTR in HL.
2A0D
OR A
Set the flags according to the string's length in register A.
2A0E
RET
Return.

2A0F-2A1E - LEVEL II BASIC "ASC" ROUTINE

The following is the ASC($) function.
It returns an integer which is the decimal ASCII equivalent

2A0F-2A11ASC
LD BC,27F8HLD B,SNGFLT
Load BC with the return address of 27F8H.
2A12
Save the return address of 27F8H (in BC) to the stack.
2A13-2A15ASC2
GOSUB to 2A07H (which itself is a GOSUB to 29D7H) to get string's VARPTR into HL and the string's length into register A.
2A16-2A18
Display a ?FC ERROR if the string's length in register A is equal to zero.
2A19
INC HL
Bump the value of the string's VARPTR in HL.
2A1A
LD E,(HL)
Load register E with the LSB of the string's address at the location of the string's VARPTR in HL.
2A1B
INC HL
Bump the value of the string's VARPTR in HL.
2A1C
LD D,(HL)
Load register D with the MSB of the string's address at the location of the string's VARPTR in HL.
2A1D
LD A,(DE)
Load register A with the first character at the location of the string pointer in DE.
2A1E
RET
Return.

2A1F-2A2E - LEVEL II BASIC "CHR$" ROUTINE - "CHR$"

CHR$(#) creates a string which contains as its only character the ASCII equivalent of the integer arg (#) which must be .LE. 255.

2A1F-2A20CHR$
LD A,01H
Load register A with the length of the string to be created.
2A21-2A23
GOSUB to 2857H to save the string's length in register A and value and set up the string's address.
2A24-2A26
GOSUB to 2B1FH to evaluate the expression at the location of the current BASIC program pointer in HL and return with the integer result in DE.
2A27-2A29INCSTR/SETSTR
LD HL,(40D4H)LD HL,(DSCTMP+INCSTR)
Load HL with the temporary string's address.
2A2A
LD (HL),E
Save the character in register E at the location of the string pointer in HL.
2A2BFINBCK
POP BC
Clean up the stack.
2A2C-2A2E
Jump to 2884H.

2A2F-2A60 - LEVEL II BASIC "STRING$" ROUTINE - "STRNG$"

2A2FSTRNG$
RST 10H
We have the STRING$ command, but now we need the next character so we call a RST 10H to bump the value of the current BASIC program pointer until it points to the next character, call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2A30-2A31
RST 08H ⇒ 28H
Since the character at the location of the current BASIC program pointer in HL must be a (, call the COMPARE SYMBOL routine at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL register to the value in the location following the RST 08 call.
  • If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
  • If the two characters do not match, a syntax error message is given and control returns to the Input Phase).
2A32-2A34
This will get the string length required (which we will call "N") via a GOSUB to 2B1CH to evaluate the expression at the location of the current BASIC program pointer in HL and return with the integer result in DE.
2A34
DEC HL
Backspace the code string. This is a Z-80 trick because this code was part of the above call instruction.
2A35
PUSH DE
Save the string's length ("N") (currently in DE) to the stack.
2A36-2A37
RST 08 ⇒ 2CH
Now we have STRING$(nnn so the next character needs to be a ,. To test for the character at the location of the current BASIC program pointer in HL being a ,, call the COMPARE SYMBOL routine which compares the symbol in the input string pointed to by HL register to the value in the location following the RST 08 call. If there is a match, control is returned to address of the RST 08 instruction + 2 with the next symbol in the A register and HL incremented by one. If the two characters do not match, a syntax error message is given and control returns to the Input Phase).
2A38-2A3A
Now we have STRING$(xxx, and an expression so GOSUB to 2337H to evaluate the expression at the location of the current BASIC program pointer in HL and return with the result in REG 1.
2A3B-2A3C
RST 08H ⇒ 29H
Now we have STRING$(nnn,X. Since the character at the location of the current BASIC program pointer in HL must be a ), call the COMPARE SYMBOL routine at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL register to the value in the location following the RST 08 call.
  • If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
  • If the two characters do not match, a syntax error message is given and control returns to the Input Phase).
2A3D
EX (SP),HL
We are now done with getting STRING$(nnn,X). Next we must exchange the value of the current BASIC program pointer in HL with the string's length ("N") in the stack.
2A3E
PUSH HL
Save the string's length ("N") in HL to the stack so that we can test it to make sure it is an integer.
2A3F
RST 20H
We need to check the value of the current data type flag, so we call the TEST DATA MODE routine at RST 20H.
NOTE: The RST 20H routine determines the type of the current value in REG 1 and returns a combination of STATUS flags and unique numeric values in the A Register according to the data mode flag (40AFH).

The results are returned as follows:
If the Variable Type is ...and the Flags
are set ...		... then Register
A will be set ...
IntegerNZ/C/M/E-1
StringZ/C/P/E0
Single PrecisionNZ/C/P/O1
Double PrecisionNZ/NC/P/E5
2A40-2A41
If that test shows "N" is a a STRING, jump to down to 2A47H.
2A42-2A44
We now know that "N" is at least a number, so we GOSUB to 2B1FH to convert the current result in REG 1 to an integer and return with the 8-bit result in register A.
2A45-2A46
Skip the next instruction (which would load the string address and 1st character) by jumping to 2A4AH.
2A47-2A49STRSTR
Go get the first character in the string and return with it in register A. This is the character that will be repeated.
2A4ACALSPA
POP DE
Get the "N" from the stack and put it in DE.
2A4B
PUSH AF
Save the character for the string (held in register A) to the stack.
2A4CSPACE2
PUSH AF
and then save it to the stack again.
2A4D
LD A,E
Load register A with "N" (held in register E).
2A4E-2A4F
GOSUB to 2857H to allocate N bytes in the temporary string work area .
2A51
LD E,A
Load register E with "N" (held in register A).
2A52
POP AF
Get the character for the string ("X") from the stack and put it in register A.
2A53
INC E
To set the status flags we need to increase and then decrease E. First, bump the value of the string's length in register E ...
2A54
DEC E
... and then decrement the string's length in register E.
2A55-2A56
If "N" was zero (so that the string is now complete), jump back to 2A2BH.
2A57-2A59
LD HL,(40D4H)LD HL,(DSCTMP+INCSTR)
If we are here, we have not finished building the STRING$ string so now we load HL with the string's address and get ready to loop.
2A5ASPLP$
LD (HL),A
Save the character in register A ("X") at the location of the string pointer in HL.
2A5B
INC HL
Bump the value of the string pointer in HL.
2A5C
DEC E
Decrement the string's length in register E.
2A5D-2A5E
Loop back to 2A5AH to keep filling (HL) until the string of X's has been completed.
2A5F-2A60
Jump back to 2A2BH.

2A61-2A90 - LEVEL II BASIC "LEFT$(" ROUTINE - On entry, HL=address of LEFT$, the stack = string address, stack+1 = n, and DE = code string address - "LEFT$"

The following is the LEFT$($,#) function.
It takes the leftmost # chars of the str.
If # is .GT. than the len of the str, it returns the whole str.

2A61-2A63LEFT$
Go check the syntax. The character at the location of the current BASIC program pointer in HL must be a ).
2A64
XOR A
Zero register A.
2A65LEFT3
EX (SP),HL
Exchange the value of the current BASIC program pointer in HL with the string's VARPTR to the stack.
2A66
LD C,A
Zero register C.
2A67-2A68
3E E5
Z-80 Trick. By adding a 3E at 2A67, it masks out 2A68H if passing through by making the Z-80 think the instruction is LD A,0E5H.

This is print usings entry point into LEFT$

2A68LEFTUS
PUSH HL
PUSH HL. Not executed in a passdown.
2A69LEFT2
PUSH HL
Save the value of the string's VARPTR in HL to the stack.
2A6A
LD A,(HL)
Load register A with the string's length at the location of the string's VARPTR in HL.
2A6B
CP B
Check to see if the new string's length in register B is greater than the string's length in register A.
2A6C-2A6D
Jump to 2A70H if the new string's length in register B is greater than the string's length in register A.
2A6E
LD A,B
Load register A with the new string's length in register B.
2A6F-2A71
11 0E 00
Z-80 Trick. This is a LD DE,000EH which is irrelevant and only executed if continuing through. If, however, one was to jump to 2A70H instead, a proper opcode would occur.
2A70-2A7lALLSTR
LD C,00H
Zero the offset held in register C.
2A72
PUSH BC
Save the string's length in BC to the stack.
2A73-2A75
Go see if there is enough string space for the new string.
2A76
POP BC
Get the new string's length from the stack and put it in BC.
2A77
POP HL
Get the string's VARPTR from the stack and put it in HL.
2A78
PUSH HL
Save the string's VARPTR in HL to the stack.
2A79
INC HL
Bump the value of the string's VARPTR in HL.
2A7A
LD B,(HL)
Load register B with the LSB of the string's address at the location of the string's VARPTR in HL.
2A7B
INC HL
Bump the value of the string's VARPTR in HL.
2A7C
LD H,(HL)
Load register H with the MSB of the string's address at the location of the string's VARPTR in HL.
2A7D
LD L,B
Load register L with the LSB of the string's address in register B.
2A7E-2A7F
LD B,00H
Zero register B.
2A80
ADD HL,BC
Add the string's length in BC to the string's address in HL.
2A81
LD B,H
Load register B with the MSB of the string's ending address in register H.
2A82
LD C,L
Load register C with the LSB of the string's ending address in register L.
2A83-2A85
Go save the string's length (held in A) and the string's starting address (held in DE).
2A86
LD L,A
Load register L with the string's length (i.e., the number of characters to move) held in register A.
2A87-2A89
Go move L characers frm BC to DE.
2A8A
POP DE
Clean up the stack.
2A8B-2A8D
Go update the temporary string work area.
2A8E-2A90
Jump to 2884H.

2A91-2A99 - LEVEL II BASIC RIGHT$ ROUTINE - "RIGHT$"

2A91-2A93RIGHT$
Go check the syntax. The character at the location of the current BASIC program pointer in HL must be a ).
2A94
POP DE
Get the string's VARPTR from the stack and put it in DE.
2A95
PUSH DE
Save the string's VARPTR in DE to the stack.
2A96
LD A,(DE)
Load register A with the string's length (held at the location of the string's VARPTR in DE).
2A97
SUB B
Subtract the new string's length in register B from the string's length in register A to isolate the number of bytes.
2A98-2A99
Jump to the LEFT$( code.

2A9A-2AC4 - LEVEL II BASIC MID$ ROUTINE - "MID$"

MID ($,#) returns str with chars from # position onward.
If # is GT LEN($) then return null string.
MID ($,#,#) returns str with chars from # position for #2 chars.
If #2 goes past end of string, return as much as possible.

2A9AMID$
EX DE,HL
Load HL with the value of the current BASIC program pointer (held in DE).
2A9B
LD A,(HL)
Load register A with the terminal character, currently held at the location of the current BASIC program pointer in HL.
2A9C-2A9E
GOSUB to 2AE2H to get the string's position in register B and the string's VARPTR in DE.
2A9F
INC B
We need to set the status flags to correspond to the position value so we first bump the value of the string's position in register B ...
2AA0
DEC B
... and then we decrement the value of the string's position in register B.
2AA1-2AAJ
If the starting position (held in B) is 0, display ?FC ERROR.
2AA4
PUSH BC
Save the value of the string's starting position (held in register B) to the stack.
2AA5-2AA6
LD E,0FFH
Load register E with the default string's length of 256 in case no number of bytes are given.
2AA7-2AA8
CP 29H
More syntax checking. Here we need to test for a ) at the location of the current BASIC program pointer.
2AA9-2AAA
Jump to 2AB0H if the character at the location of the current BASIC program pointer in register A is a ).
2AAB-2AAC
RST 08H ⇒ 2CH
If it wasn't a ), it had best be a , so we need to test the character at the location of the current BASIC program pointer in HL by calling the COMPARE SYMBOL routine at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL register to the value in the location following the RST 08 call.
  • If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
  • If the two characters do not match, a syntax error message is given and control returns to the Input Phase).
2AAD-2AAF
Go evaluate the expression at the location of the current BASIC program pointer in HL and return with the integer result in DE. Now the byte count is in DE as an integer.
2AB0-2AB1MID2
RST 08H ⇒ 29H
Since the character at the location of the current BASIC program pointer in HL must be a ), call the COMPARE SYMBOL routine at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL register to the value in the location following the RST 08 call.
  • If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
  • If the two characters do not match, a syntax error message is given and control returns to the Input Phase).
2AB2
POP AF
Get the value of the string'starting s position from the stack and put it in register A.
2AB3
EX (SP),HL
Exchange the value of the current BASIC program pointer in HL with the value of the string's VARPTR to the stack.
2AB4-2AB6
LD BC,2A69HLD B,LEFT2
Load BC with 2A69H as the return address (which is in the LEFT$ routine).
2AB7
PUSH BC
Save the return address in BC to the stack.
2AB8
DEC A
Decrement the value of the string's position in register A so that we have a starting position minus 1.
2AB9
CP (HL)
Compare the string's length at the location of the string's VARPTR in HL with the value of the string's position in register A.
2ABA-2ABB
LD B,00H
Zero register B.
2ABC
RET NC
Return if the string's position in register A is greater than the string's length at the location of the string's VARPTR in HL.
2ABD
LD C,A
Load register C with the string's position in register A.
2ABE
LD A,(HL)
Load register A with the string's length at the location of the string's VARPTR in HL.
2ABF
SUB C
Subtract the value of the string's position in register C from the string's length in register A.
2AC0
CP E
Compare the new string's length in register E with the adjusted string's length in register A.
2AC1
LD B,A
Load register B with the adjusted string's length in register A.
2AC2
Return to 2A69H if the new string's length in register E is greater than the string's length in register A.
2AC3
LD B,E
Load register B with the new string's length in register E.
2AC4
Return to 2A69H.

2AC5-2ADE - LEVEL II BASIC "VAL" ROUTINE - "VAL"

The VAL function takes a string and turn it into a number by interpreting the ASCII digits.
Etc..
Except for the problem that a terminator must be supplied by replacing the character beyond the string, VAL is merely a call to floating input (FIN).

2AC5-2AC7VAL
Go get the string's length in register A and the string's VARPTR in HL.
2AC8-2ACA
Jump to 27F8H if the string's length in register A is equal to zero.
2ACB
LD E,A
Load register E with the string's length at the location of the string's VARPTR in HL.
2ACC
INC HL
Bump the value of the string's VARPTR in HL.
2ACD
LD A,(HL)
Load register A with the LSB of the string's address at the location of the string's VARPTR in HL.
2ACE
INC HL
Bump the value of the string's VARPTR in HL.
2ACF
LD H,(HL)
Load register H with the MSB of the string's address at the location of the string's VARPTR in HL.
2ADO
LD L,A
Load register L with the LSB of the string's address in register A.
2AD1
PUSH HL
Save the value of the string's address in HL to the stack.
2AD2
ADD HL,DE
Add the string's length in DE to the string's address in HL.
2AD3
LD B,(HL)
Load register B with the last character of the string at the location of the string pointer in HL.
2AD4
LD (HL),D
Save the zero in register D at the location of the string pointer in HL.
2AD5
EX (SP),HL
Exchange the string's ending address in HL with the string's address to the stack.
2AD6
PUSH BC
Save the last character of the string in register B to the stack.
2AD7
LD A,(HL)
Load register A with the character at the location of the string pointer in HL.
2AD8-2ADA
Call the ASCII TO DOUBLE routine at 0E65H (which converts the ASCII string pointed to by HL to its double precision equivalent; with output left in REG 1).
2ADB
POP BC
Get the last character of the string from the stack and put it in register B.
2ADC
POP HL
Get the string's ending address from the stack and put it in HL.
2ADD
LD (HL),B
Save the character in register B at the location of the string pointer in HL.
2ADE
RET
Return.

2ADF-2A6 - STRING ROUTINE - "PREAM"

This is called by LEFT$, MID$, and RIGHT$ to test for the ending ")" character. On entry, the stack has the string address, byte count, and return address. On exit the stack has the string address, DE and B each have the byte count.

2ADFPREAM
EX DE,HL
Load HL with the value of the current BASIC program pointer in DE.
2AE0-2AE1
RST 08H ⇒ 29H
Since the character at the location of the current BASIC program pointer in HL must be a ), call the COMPARE SYMBOL routine at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL register to the value in the location following the RST 08 call.
  • If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
  • If the two characters do not match, a syntax error message is given and control returns to the Input Phase).

Used by MID$ for parameter checking and setup

2AE2PREAM2
POP BC
Get the return address from the stack and put it in BC.
2AE3
POP DE
Get the number of bytes to isolate from the string (from the stack) and put it in DE.
2AE4
PUSH BC
Save the return address in BC to the stack.
2AE5
LD B,E
Load register B with the number of bytes in register E.
2AE6
RET
Return.

2AE7H-2AEEH STRING FUNCTIONS - LEFT HAND SIDE MID$

2AE7-2AE8ISMID
CP 7AHCP MIDTK-$END
Check to see if the character at the location of the current BASIC program pointer in register A is equal to 7AH (which is a lower case z).
2AE9-2AEB
Display a ?SN ERROR message if the character at the location of the current BASIC program pointer in register A isn't equal to 7AH.
2AEC-2AEE
Jump to the DOS link at 41D9H to let disk BASIC handle TAB-MID$.

2AEF-2AF7 - LEVEL II BASIC "INP" ROUTINE - "FNINP"

The following functions allow the user full access to the I/O ports.
INP(CHANNEL#) returns an integer which is the status of the channel.
OUT CHANNEL#,VALUE puts out the integer value on channel #.
It is a statement, not a function.

2AEF-2AF1FNINP
Go evaluate the expression at the location of the current BASIC program pointer in HL and return with the port number in register A.
2AF2-2AF4
LD (4094H),ALD (STAINP+1),A
Save the value of the port number (from register A) into 4094H.
2AF5-2AF7
Go get the value from the port, execute an IN xx instruction, and return to the execution driver.
Note: 4093H-4095H holds INP routine.

2AF8-2B00 - LEVEL II BASIC "OUT" ROUTINE

2AF8-2AFA
Go evaluate the expression at the location of the current BASIC program pointer in HL and return with the port number saved in memory.
2AFB-2AFDFNOUT
Go evaluate the expression at the location of the current BASIC program pointer in HL and return with value to send to the port in register A.
2AFE-2B00
Go send the value in register A, execute an OUT xx instruction to the port, and return.
Note: 4096H-4098H holds OUT routine.

2B01-2B0D - THIS IS THE CONSOLE (CHANNEL NUMBER,SENSE SWITCH SETTING) COMMAND.

2B01GETINT
RST 10H
We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2B02-2B04GETIN2
Go evaluate the expression at the location of the current BASIC program pointer in HL and return with the result in REG 1.

2B05 - This routine takes the value from the ACC, converts it to an integer value and places the result in the DE register pair. The Z flag will be set if the result in DE is smaller than or equal to 255 (FFH). (DE = INT (ACC)).

2B05INTFR2
PUSH HL
Save the value of the current BASIC program pointer in HL to the stack.
2B06-2B08
Call the CONVERT TO INTEGER routine at 0A7FH (where the contents of REG 1 are converted from single or double precision to integer and deposited into HL).
2B09
EX DE,HL
Load DE with the integer result in HL.
2B0A
POP HL
Get the value of the current BASIC program pointer from the stack and put it in HL.
2B0B
LD A,D
Load register A with the MSB of the integer result in register D.
2B0C
OR A
Test the value of the MSB in register A.
2B0D
RET
Return.

2B0E-2B16 - EVALUATE EXPRESSION ROUTINE - "OUT" continues here

2B0E-2B10SETIO
GOSUB to 2B1CH to evaluate the expression at the location of the current BASIC program pointer in HL and return with the 8-bit value in register A.
2B11-2B13
LD (4094H),ALD (STAINP+1),A
Save the 8-bit value in register A in the DOS address of 4094H.
2B14-2B16
LD (4097H),ALD (OUTWRD+1),A
Save the 8-bit value in register A in the DOS address of 4097H.

2B17-2B1A - CHECK SYNTAX ROUTINE - This checks to see if the next character is a """ and contnues on to 2B1CH if it is, and errors out if it isn't.

2B17-2B18
RST 08H ⇒ 2EH
Since the character at the location of the current BASIC program pointer in HL must be a ",", call the COMPARE SYMBOL routine at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL register to the value in the location following the RST 08 call.
  • If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
  • If the two characters do not match, a syntax error message is given and control returns to the Input Phase).
2B19-2B1A
Jump forward to 2B1CH.

2BlB-2B28 - EVALUATE EXPRESSION ROUTINE - This is called by "PRINT TAB".

2B1BGTBYTC
RST 10H
We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.

2B1C - This routine converts a numeric ASCII string pointed to by the HL into a hexadecimal value and places the result in the A register.

If the result is larger than 255 (FFH) then an FC ERROR (Illegal function call) will be generated. After execution the HL will point to the delimiter. If the delimiter is a zero byte or a colon (3AH) then the Z flag will be set. Any other delimiter will cause the Z flag to be reset.

2B1C-2B1EGETBYT
GOSUB to 2337H to evaluate the expression at the location of the current BASIC program pointer in HL and return with the result in REG l.
2B1F-2B21CONINT
GOSUB to 2B05H to convert the result in REG 1 to an integer and return with the integer result in DE.
2B22-2B24
If the result is greater than 255, display a ?FC ERROR message.
2B25
DEC HL
Decrement the value of the current BASIC program pointer in HL.
2B26
RST 10H
We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2B27
LD A,E
Load register A with the 8-bit result in register E.
2B28
RET
Return.

2B29-2B2D - LEVEL II BASIC "LLIST" ROUTINE

This routine sets the output device flag to PRINTER and then flows through to the LIST command.

2B29-2B2ALLIST
LD A,01H
Load register A with the printer output device code.
2B2B-2B2D
LD (409CH),ALD (PRTFLG),A
Save the value in register A as the current output device flag.
Note: 409CH holds the current output device flag: -1=cassette, 0=video and 1=printer.

2B2E-2B74 - LEVEL II BASIC "LIST" ROUTINE.

On entry the stack has the return address, then the first basic line number to be listed, then the last basic line number to be listed.

2B2ELIST
POP BC
Get the return address from the stack and put it in BC.
2B2F-2B31
Go evaluate the range of line numbers given at the location of the current BASIC program pointer in HL.
2B32
PUSH BC
Save the address of the first BASIC line (held in BC) to the stack.
2B33-2B35LIST4
LD HL,FFFFH
Load HL with a -1. This is because the below loop starts with a INC HL, so as to turn the first line number into 0.
2B36-2B38
LD (40A2H),HLLD (CURLIN),HL
Save the value in HL as the current BASIC line number.
NOTE:40A2H-40A3H holds the current BASIC line number.
2B39
POP HL
Get the address of the first BASIC line to be listed (from the stack) and put it in HL.
2B3A
POP DE
Get the value of the last BASIC line number to be listed (from the stack) and put it in DE.
2B3B
LD C,(HL)
Load register C with the LSB of the next BASIC line pointer at the location of the memory pointer in HL.
2B3C
INC HL
Bump the value of the memory pointer in HL.
2B3D
LD B,(HL)
Load register B with the MSB of the next BASIC line pointer at the location of the memory pointer in HL.
2B3E
INC HL
Bump the value of the memory pointer in HL.
2B3F
LD A,B
Load register A with the MSB of the next BASIC line pointer in register B.
2B40
OR C
Combine the LSB of the next BASIC line pointer in register C with the MSB of the next BASIC line pointer in register A. This will let us test for the end of the BASIC program.
2B41-2B43
Jump to 1A19H if this is the end of the BASIC program.
2B44-2B46
Go call the DOS link at 41DFH.
In NEWDOS 2.1, this is called from LIST processing.
2B47-2B49
Go scan the keyboard to see if the BREAK key or the shift-@ key was pressed.
2B4A
PUSH BC
Save the address of the next BASIC line in BC to the stack.
2B4B
LD C,(HL)
Load register C with the LSB of the BASIC line number at the location of the memory pointer in HL.
2B4C
INC HL
Bump the value of the memory pointer in HL.
2B4D
LD B,(HL)
Load register B with the MSB of the BASIC line number at the location of the memory pointer in HL.
2B4E
INC HL
Bump the value of the memory pointer in HL.
2B4F
PUSH BC
Save the BASIC line number in BC to the stack.
2B50
EX (SP),HL
Exchange the value of the memory pointer in HL with the value of the BASIC line number to the stack.
2B51
EX DE,HL
Exchange the value of the BASIC line number in HL with the value of the last BASIC line number in DE.
2B52
RST 18H
Now we need to compare the BASIC line number in DE with the last BASIC line number in HL, so we call the COMPARE DE:HL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2B53
POP BC
Get the value of the memory pointer from the stack and put it in BC.
2B54-2B56
Jump to 1A18H if the BASIC line number in DE is greater than the last BASIC line number in HL.
2B57
EX (SP),HL
Exchange the value of the last BASIC line number in HL with the address of the next BASIC line to the stack.
2B58
PUSH HL
Save the address of the next BASIC line in HL to the stack.
2B59
PUSH BC
Save the memory pointer in BC to the stack.
2B5A
EX DE,HL
Load HL with the BASIC line number in DE.
2B5B-2B5D
LD (40ECH),HLLD (DOT),HL
Save the BASIC line number in HL.
Note: 40ECH-40EDH holds EDIT line number.
2B5E-2B60
Call the HL TO ASCII routine at 0FAFH (which converts the value in the HL (assumed to be an integer) to ASCII and display it at the current cursor position on the video screen) to display the current BASIC line number.
2B61-2B62
LD A,20H
Load register A with a space.
2B63
POP HL
Get the value of the memory pointer from the stack and put it in HL.
2B64-2B66
Go send the space in register A to the current output device.
2B67-2B69
GOSUB to 2B7EH move the BASIC line at the location of the memory pointer in HL into the input buffer and untokenize the BASIC line.
2B6A-2B6C
LD HL,(40A7H)LD HL,(BUFPNT)
Load HL with the starting address of the input buffer.
Note: 40A7H-40A8H holds the input Buffer pointer.
2B6D-2B6F
Since we need to send the BASIC line in the input buffer to the current output device we call the PRINT MESSAGE routine at 2B75H which writes string pointed to by HL to the current output device.
2B70-2B72
Go send a carriage return to the current output device.
2B73-2B74
Loop back to 2B33H until the listing is complete.

2B75-2B7D - DISPLAY MESSAGE ROUTINE - "LISPRT

This is the PRINT MESSAGE routine which writes string pointed to by HL to the current output device. String must be terminated by a byte of zeros. This call is different from 28A7H because it does not use the literal string pool area, but it does use the same display routine and it takes the same DOS Exit at 41C1H. Uses all registers. This routine can be called without loading the BASIC utility, if a C9H (RET) is stored in 41C1H.

This routine outputs a string to device indicated by device type flag stored at 409CH. String must end with zero byte. On entry, HL registers must point to address of start of string. Calls routine at 032AH.

2B75LISPRT
LD A,(HL)
Load register A with the character at the location of the memory pointer in HL.
2B76
OR A
Check to see if the character in register A is an end of the string character (00H).
2B77
RET Z
Return if the character in register A is an end of the string character.
2B78-2B7A
Go send the character in register A to the current output device.
2B7B
INC HL
Bump the value of the memory pointer in HL.
2B7C-2B7D
Loop back to 2B75H until all of the characters have been sent to the current output device.

2B7E-2BC5 - UNTOKENIZE ROUTINE - "BUFLIN"

This routine is called by LIST and EDIT. It moves the line pointed to by HL to the input buffer area and then expands each token into the appropriate key word.

2B7EBUFLIN
PUSH HL
Save the BASIC line pointer in HL to the stack.
2B7F-2B81
LD HL,(40A7H)LD HL,(BUFPNT)
Load HL with the starting address of the input buffer.
Note: 40A7H-40A8H holds the input Buffer pointer.
2B82
LD B,H
Load register B with the MSB of the input buffer pointer in register H.
2B83
LD C,L
Load register C with the LSB of the input buffer pointer in register L.
2B84
POP HL
Get the value of the BASIC line pointer from the stack and put it in HL.
*2B85-2B87
JUMP to 069AH to clear A and all flags, load the data flag (at 409FH) with 0, load D with 255 (a buffer), and JUMP to 2B8DH.
Difference between M1 and M3 ROMs: This change is to the LIST command. JP 069AH in the Model III replaces LD D,0FFH followed by JR 2B8CH in the Model I.
*2B88
NOP
No Operation
2B89PLOOP
INC BC
Bump the value of the input buffer pointer in BC.
2B8A
DEC D
Decrement the character count in register D.
2B8B
RET Z
Return if 256 characters have been moved into the input buffer.
*2B8CPLOOP2
INC HL
Move one byte forward in the text.
Difference between M1 and M3 ROMs: Another change to LIST. In the Model I three instructions occupied this area: LD A,(HL); OR A; INC HL. In the Model III the INC HL instruction is moved to the beginning of the three.
*2B8D
LD A,(HL)
Load register A with the character at the location of the BASIC line pointer in HL.
*2B8E
OR A
Set the status flags to enable us to check to see if the character in register A is an end of the BASIC line character.
2B8F
LD (BC),A
Save the character at the location of the input buffer pointer (held in register A) to the memory location held by BC.
2B90
RET Z
Return if the character in register A is an end of the BASIC line character.
*2B91-2B93
Jump to 302DH, which JUMPS to 377B.

Difference between M1 and M3 ROMs: The final change to LIST - a JP P,2B89H instruction in the Model I is changed to a JP 302DH instruction in the Model III.

2B94-2B95
CP FBHCP SNGQTK
Check to see if the character in register A is a ' token.
2B96-2B97
Jump forward to 2BA0H if the character in register A isn't a ' token.
2B98
DEC BC
The next bunch of opcodes is to backspace the expanded buffer pointer by 4 and then adjust the count of characters in the buffer. First, decrement the value of the input buffer pointer in BC.
2B99
DEC BC
Decrement the value of the input buffer pointer in BC.
2B9A
DEC BC
Decrement the value of the input buffer pointer in BC.
2B9B
DEC BC
Decrement the value of the input buffer pointer in BC.
2B9C
INC D
Bump the value of the character counter in register D.
2B9D
INC D
Bump the value of the character counter in register D.
2B9E
INC D
Bump the value of the character counter in register D.
2B9F
INC D
Bump the value of the character counter in register D.
2BA0-2BA1NTQTTK
CP 95HCP $ELSE
Check to see if the character in register A is an ELSE token.
2BA2-2BA4
If it was an ELSE we need to backspace the expanded buffer pointer so ... go back to 0B24H to decrement the value of the input buffer pointer if the character in register A is an ELSE token.
2BA5-2BA6
SUB 7FH
Subtract 7F to get the number of the entry we are looking for in token list.
2BA7
PUSH HL
Save the value of the BASIC line pointer in HL to the stack.
2BA8
LD E,A
Load register E with the character in register A.
2BA9-2BAB
LD HL,1650HLD HL,RESLST
Load HL with the starting address of the reserved words list.
2BACLOPRES
LD A,(HL)
Load register A with the character at the location of the reserved words list pointer in HL.
2BAD
OR A
Test the value of the character in register A.
2BAE
INC HL
Bump the value of the reserved words list pointer in HL.
2BAF-2BB1
Jump back to 2BACH if the character at the location of the reserved words pointer in register A doesn't have bit 7 set.
2BB2
DEC E
Decrement the value of the token in register E.
2BB3-2BB4
Jump back to 2BACH if this isn't the reserved word for the token.
2BB5-2BB6
AND 7FH
Reset bit 7 of the character in register A by ANDing it against 0111 1111.
2BB7MORPUR
LD (BC),A
Save the character in register A at the location of the input buffer pointer in BC.
2BB8
INC BC
Bump the value of the input buffer pointer in BC.
2BB9
DEC D
Decrement the value of the character counter in register D.
2BBA-2BBC
Jump back to 28D8H if the maximum number of characters have been put into the input buffer.
2BBD
LD A,(HL)
Load register A with the character at the location of the reserved words pointer in HL.
2BBE
INC HL
Bump the reserved words pointer in HL.
2BBF
OR A
Test the value of the character in register A.
2BC0-2BC2
Jump back to 2BB7H if bit 7 of the character in register A isn't set.
2BC3
POP HL
Get the value of the BASIC line pointer from the stack and put it in HL.
2BC4-2BC5
Jump back to 2B8CH.

The following code is for the delete range command.
Before the lines are deleted, 'OK' is typed.

2BC6-2BC8DELETE
GOSUB to 1B10H to evaluate the line numbers at the location of the current BASIC program pointer in HL.
2BC9
POP DE
Get the value of the last BASIC line number to be deleted (in binary) from the stack and put it in DE.
2BCA
PUSH BC
Save the address of the first BASIC line to be deleted in BC to the stack.
2BCB
PUSH BC
Save the address of the first BASIC line to be deleted in BC to the stack AGAIN!.
2BCC-2BCE
GOSUB to 1B2CH to the SEARCH FOR LINE NUMBER routine which looks for the line number specified in DE so as to get the address of the last line to be deleted.Returns C/Z with the line found in BC, NC/Z with line number is too large and HL/BC having the next available location, or NC/NZ with line number not found, and BC has the first available one after that.
2BCF-2BD0
Goto 2BD6H to show a ?FC ERROR if the SEARCH FOR LINE NUMBER routine returns a NC, that means that the line searched for (in this case, the last line to be deleted) does not exist; and if that's the case, jump to 2BDH6.
2BD1
LD D,H
Load register D with the MSB of the last BASIC line's address in register H.
2BD2
LD E,L
Load register E with the LSB of the last BASIC line's address in register L.
2BD3
EX (SP),HL
Exchange the last BASIC line's address in HL with the first BASIC line's address to the stack.
2BD4
PUSH HL
Save the first BASIC line's address in HL to the stack.
2BD5
RST 18H
Now we need to check to see if the first BASIC line's address in HL is greater than or equal to the last BASIC line's address in DE, so we call the COMPARE DE:HL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2BD6-2BD8FCERRG
Display a ?FC ERROR message if the first BASIC lines address in HL is greater than or equal to the last BASIC line's address in DE.
2BD9-2BDB
LD HL,1929HLD HL,REDDY
Load HL with the starting address of the BASIC READY message.
2BDC-2BDE
We need to display the Level II BASIC READY message, so we call the WRITE MESSAGE routine at 28A7H.
NOTE:
  • The routine at 28A7 displays the message pointed to by HL on current system output device (usually video).
  • The string to be displayed must be terminated by a byte of machine zeros or a carriage return code 0D.
  • If terminated with a carriage return, control is returned to the caller after taking the DOS exit at 41D0H (JP 5B99H).
2BDF
POP BC
Get the first BASIC line's address from the stack and put it in BC.
2BE0-2BE2
LD HL,1AE8HLD HL,FINI
Load HL with the return address.
2BE3
EX (SP),HL
Exchange the value of the return address in HL with the value of the last BASIC line's address to the stack.
2BE4DEL
EX DE,HL
Load DE with the last BASIC line's address in HL.
2BE5-2BE7
LD HL,(40F9H)LD HL,(VARTAB)
Load HL with the end of the BASIC program pointer.
  • Note: 40F9H-40FAH holds the starting address of the simple variable storage area.
2BE8MLOOP
LD A,(DE)
Load register A with the character at the location of the memory pointer in DE.
2BE9
LD (BC),A
Save the character in register A at the location of the memory pointer in BC.
2BEA
INC BC
Bump the value of the memory pointer in BC.
2BEB
INC DE
Bump the value of the memory pointer in DE.
2BEC
RST 18H
Now we need to check to see if the memory pointer in DE equals the end of the BASIC program pointer in HL, so we call the COMPARE DE:HL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2BED-2BEE
Loop back to 2BE8H until the memory pointer in DE equals the end of the BASIC program pointer in HL.
2BD3
EX (SP),HL
Exchange the last BASIC line's address in HL with the first BASIC line's address to the stack.
2BD4
PUSH HL
Save the first BASIC line's address in HL to the stack.
2BD5
RST 18H
Now we need to check to see if the first BASIC line's address in HL is greater than or equal to the last BASIC line's address in DE, so we call the COMPARE DE:HL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2BD6-2BD8
Display a ?FC ERROR if the first BASIC lines address in HL is greater than or equal to the last BASIC line's address in DE.
2BD9-2BDB
LD HL,1929H
Load HL with the starting address of the BASIC READY message.
2BDC-2BDE
We need to display the Level II BASIC READY message, so we call the WRITE MESSAGE routine at 28A7H.
NOTE:
  • The routine at 28A7 displays the message pointed to by HL on current system output device (usually video).
  • The string to be displayed must be terminated by a byte of machine zeros or a carriage return code 0D.
  • If terminated with a carriage return, control is returned to the caller after taking the DOS exit at 41D0H (JP 5B99H).
2BDF
POP BC
Get the first BASIC line's address from the stack and put it in BC.
2BE0-2BE2
LD HL,1AE8H
Load HL with the return address.
2BE3
EX (SP),HL
Exchange the value of the return address in HL with the value of the last BASIC line's address to the stack.
2BE4
EX DE,HL
Load DE with the last BASIC line's address in HL.
2BE5-2BE7
LD HL,(40F9H)LD HL,(VARTAB)
Load HL with the end of the BASIC program pointer.
  • Note: 40F9H-40FAH holds the starting address of the simple variable storage area.
2BE8
LD A,(DE)
Load register A with the character at the location of the memory pointer in DE.
2BE9
LD (BC),A
Save the character in register A at the location of the memory pointer in BC.
2BEA
INC BC
Bump the value of the memory pointer in BC.
2BEB
INC DE
Bump the value of the memory pointer in DE.
2BEC
RST 18H
Now we need to check to see if the memory pointer in DE equals the end of the BASIC program pointer in HL, so we call the COMPARE DE:HL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2BED-2BEE
Loop until the memory pointer in DE equals the end of the BASIC program pointer in HL.
2BEF
LD H,B
Load register H with the MSB of the memory pointer in register B.
2BF0
LD L,C
Load register L with the LSB of the memory pointer in register C.
2BF1-2BF3
LD (40F9H),HLLD (VARTAB),HL
Save the value in HL as the new end of the BASIC program pointer.
  • Note: 40F9H-40FAH holds the starting address of the simple variable storage area.
2BF4
RET
Return.

2BF5-2C1E - LEVEL II BASIC CSAVE ROUTINE

The CSAVE command writes a program onto cassette by dumping BASICs core.
The header is three 211's followed by a one character file name.
The end is three zeros in a row.

2BF5-2BF7CSAVE
Calls the WRITE LEADER routine at 0284H (which writes a Level II leader on the cassette unit set in register A).
2BF8
2BFAH Go evaluate the rest of the CSAVE expression at the location of the current BASIC program pointer in HL and return with the result in REG l.
2BFB
PUSH HL
Save the value of the current BASIC program pointer in HL to the stack so we can get it back at the end of the routine.
2BFC-2BFE
Go get the starting address of the filename into DE.
2BFF-2C00
LD A,D3H
Load register A with the filename header byte (=D3H which is a "S" with the sign bit on).
2C01-2C03
the WRITE ONE BYTE TO CASSETTE routine at 0264H (which writes the byte in the A register to the cassette drive selected in the A register), which in this case the filename header byte.
2C04-2C06
Go write the filename header byte in register A twice more.
2C07
LD A,(DE)
Load register A with the first character of the filename at the location of the filename pointer in DE.
2C08-2C0A
the WRITE ONE BYTE TO CASSETTE routine at 0264H (which writes the byte in the A register to the cassette drive selected in the A register), which in this case is the filename.
2C0B-2C0D
LD HL,(40A4H)LD HL,(TXTTAB)
Load HL with the start of the BASIC program pointer
NOTE: 40A4H-40A5H holds the starting address of BASIC program text also known as the PROGRAM STATEMENT TABLE (PST).
2C0E
EX DE,HL
Load DE with the start of the BASIC program pointer in HL.
2C0F-2C11
LD HL,(40F9H)LD HL,(VARTAB)
Load HL with the end of the BASIC program pointer.
  • Note: 40F9H-40FAH holds the starting address of the simple variable storage area.
2C12LOPCSO
LD A,(DE)
We are going to loop from DE (start of program) to HL (end of program) now. Load register A with the character at the location of the memory pointer in DE.
2C13
INC DE
Bump the value of the memory pointer in DE.
2C14-2C16
the WRITE ONE BYTE TO CASSETTE routine at 0264H (which writes the byte in the A register to the cassette drive selected in the A register).
2C17
RST 18H
Now we need to check to see if the memory pointer in DE is equal to the end of the BASIC program pointer in HL, so we call the COMPARE DE:HL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2C18-2C19
Loop back to 2C12H until the memory pointer in DE is equal to the end of the BASIC program pointer in HL.
2C1A-2C1C
All done! GOSUB 01F8H to turn the cassette recorder off.
2C1D
POP HL
Get the value of the current BASIC program pointer from the stack and put it in HL.
2C1E
RET
Return.

2C1F-2CA4 - LEVEL II BASIC CLOAD ROUTINE

The CLOAD command clears core and then reads a program from cassette.
Since the links of the file on cassette will be wrong if the file was saved with a different version of BASIC FINI is jumped to.
A scratch is done at the start so restarts at 0 won't leave things in a garbage state.
If the CLOAD file name is preceded by a question mark then a "CVER" is done, which compares the file in core with the file on tape

Difference between M1 and M3 ROMs:Another change that originated in the "new" ROM Model I modified the CLOAD command (changed the order of portions of the CLOAD routine, disallowed CLOAD from cassette drive #2, etc.).

2C1FCLOAD
SUB 0B2H
Test for CLOAD?
2C21
Jump to 2C25H if it is CLOAD?
2C23
XOR A
Signal CLOAD (not CLOAD?)
2C24
LD BC,232FH
Z-80 TRICK: CPL A=-1 if CLOAD?, 0000 if CLOAD
2C25CLOADP
CPL
Make A=0 for VERIFY
2C26
INC HL
Point to the next character after the "?"
2C27
PUSH AF
Increment HL to the filname of the CLOAD/CLOAD? flag
2C28
LD A,(HL)
Set the next element from the code string, which should be the filename
2C29
OR A
Set status flags
2C2A
If it is the EOL, jump to 2C33H
2C2C
Call 2337H to get the filename.
2C2F
Call 2A13H to get the address of the filename into DE
2C32
LD A,(DE)
Get the filename
2C33CLNONM
LD L,A
Move the filename into Register L
2C34
POP AF
Restore the CLOAD/CLOAD? flag
2C35
OR A
Set the status register according to that flag
2C36
LD H,A
H will now hold CLOAD/CLOAD? flag, and L will hold the filename
2C37
LD (4121H),HLLD (FACLO),HL
Put the flag and filename into REG 1.
2C3A
If the flag is a CLOAD, call the NEW routine at 1B4DH.
2C3D
LD HL,0000H
Cause the drive to be selected
2C40
Call 2093H to get the leader and sync byte from the cassette.
2C43
LD HL,(4121H)LD HL,(FACLO)
Restore the CLOAD/CLOAD? flag and filename
2C46
EX DE,HL
Load DE with the CLOAD/CLOAD? flag and load the filename into HL.
2C47-2C48
LD B,03H
Load register B with the number of bytes for the filename header to match against (which is 3 ... 3 S's with the sign bit on).
2C49-2C4B
Calls the READ ONE BYTE FROM CASSETTE routine at 0235H (which reads one byte from the cassette drive specified in register A, and returns the byte in register A).
2C4C-2C4D
SUB 0D3H
Check to see if the character in register A is a filename header byte.
2C4E-2C4F
Loop if the character in register A isn't a filename header byte.
2C50-2C51
Loop back to 2C49H until three filename header bytes (3 S's with the sign bit on) have been read.
2C52-2C54
Now that the header is out of the way, let's start working on the filename. GOSUB to 0235H to the READ ONE BYTE FROM CASSETTE (which reads one byte from the cassette drive specified in register A, and returns the byte in register A).
2C55
INC E
We need to test to see if a filename was even given so we have to increase and decrease E to set flags ... Bump the value of the filename in register E.
2C56
DEC E
Decrement the value of the filename in register E.
2C57-2C58
Jump to 2C5CH if no filename was specified.
2C59
CP E
If we are here, then the user has supplied a filename which is held in Register E AND we have the first byte from the tape in Register A, so we need to compare the filename specified in register E with the character in register A.

2CA5 - "BAD" message string.

2C5A-2C5B
Jump to 2C93H (to skip to the end of that file) if the filename specified in register E doesn't match the byte read from tape in register A.
2C5C-2C5ENONAMC
LD HL,(40A4H)LD HL,(TXTTAB)
If we are here, the filename on tape matches the filename given so lets start loading. Load HL with the start of the BASIC program pointer
NOTE: 40A4H-40A5H holds the starting address of BASIC program text also known as the PROGRAM STATEMENT TABLE (PST).

This loop is going to read a byte, compare it to the next byte in the program memory, jump away if it doesn't match AND CLOAD? was chosen, write (or overwrite) that byte to memory, check for a zero, and loop back if no zero was found.

2C5F-2C60DOCRS
LD B,03H
Load register B with the number of zeros to look for to stop the load (which is 3).
2C61-2C63DOCSMR
Calls the READ ONE BYTE FROM CASSETTE routine at 0235H (which reads one byte from the cassette drive specified in register A, and returns the byte in register A).
2C64
LD E,A
Load register E with the character in register A.
2C65
SUB (HL)
Compare the character we just read from the tape (held in register A) with the character at the location of the memory pointer in HL by subtracting them.
2C66
AND D
Combine the subtracted result in register A with the value of the CLOAD/CLOAD? flag in register D.
2C67-2C68
Jump to 2C8AH if CLOAD? was selected but the bytes don't match.
2C69
LD (HL),E
At this point either CLOAD? was selected and the bytes match, or CLOAD was selected. Either way, save the character we read from the tape (held in register E) to the location of the memory pointer in HL.
2C6A-2C6C
Go check for an ?OM ERROR.
2C6D
LD A,(HL)
Load register A with the character at the location of the memory pointer in HL.
2C6E
OR A
Check to see if the byte just read in register A is equal to zero.
2C6F
INC HL
Bump the value of the memory pointer in HL.
2C70-2C71
Loop if the byte in register A isn't equal to zero (meaning that it isn't end of program or end of statement).
2C72-2C74
Call the BLINK ASTERISK routine at 022CH which alternatively displays and clears an asterisk in the upper right hand corner of the video display.
2C75-2C76
Do that loop until three zeros in a row have been read from the cassette recorder.
2C77-2C79
LD (40F9H),HLLD (VARTAB),HL
By this point, HL will have been incremented all the way through the program. Save the value of the memory pointer in HL as the new end of the BASIC program pointer.
  • Note: 40F9H-40FAH holds the starting address of the simple variable storage area.
*2C7A-2C7C
GOSUB to 01F8H to turn off the tape.
Difference between M1 and M3 ROMs: Also part of CLOAD, this change turns off the tape before printing READY on the video display. In the Model I, the code from 2C7AH - 2C82H consisted of the instructions LD HL,1929H; CALL 28A7CALL STROUTH, CALL 01F8H. In the Model III the CALL to 01F8H has been moved to the beginning of these instructions.
*2C7D-2C7FOKCASS
LD HL,1929H
Load HL with the starting address of the BASIC READY message.
*2C80-2C82
We need to display the Level II BASIC READY message, so we call the WRITE MESSAGE routine at 28A7H.
NOTE:
  • The routine at 28A7 displays the message pointed to by HL on current system output device (usually video).
  • The string to be displayed must be terminated by a byte of machine zeros or a carriage return code 0D.
  • If terminated with a carriage return, control is returned to the caller after taking the DOS exit at 41D0H (JP 5B99H).
2C83-2C85
LD HL,(40A4H)LD HL,(TXTTAB)
Load HL with the start of the BASIC program pointer
NOTE: 40A4H-40A5H holds the starting address of BASIC program text also known as the PROGRAM STATEMENT TABLE (PST).
2C86
PUSH HL
Save the start of the BASIC program pointer in HL to the stack.
2C87-2C89
Jump to 1AE8H to reinitialize the BASIC interpreter and continue.
*2C8A-2C8CNOGOOD
GOSUB to 31BDH to reset the cassette I/O.
Difference between M1 and M3 ROMs: This is part of the CLOAD? routine used when a bad byte has been read from the tape. In the Model I, a LD HL, 2CA5H instruction is found here (loads HL with the starting address of the "BAD" message), while the Model III uses a CALL 31BDH instruction, which does some housekeeping in addition to pointing HL to the "BAD" message.
2C8D-2C8F
We need to display the BAD message, so we call the WRITE MESSAGE routine at 28A7H.
NOTE:
  • The routine at 28A7 displays the message pointed to by HL on current system output device (usually video).
  • The string to be displayed must be terminated by a byte of machine zeros or a carriage return code 0D.
  • If terminated with a carriage return, control is returned to the caller after taking the DOS exit at 41D0H (JP 5B99H).
2C90-2C92
Jump to 1AE8H to reinitialize the BASIC interpreter and continue.
2C93-2C95
LD (3C3EH),A
Go display the filename on the video display.
2C96-2C97
LD B,03H
Load register B with the number of zeros to be found to stop the search.
2C98-2C9A
Calls the READ ONE BYTE FROM CASSETTE routine at 0235H (which reads one byte from the cassette drive specified in register A, and returns the byte in register A).
2C9B
OR A
Check to see if the character in register A is equal to zero.
2C9C-2C9D
Loop if the character in register A isn't equal to zero.
2C9E-2C9F
Loop until three zeros in a row have been read from the cassette recorder.
2CA0-2CA2
Calls the READ CASSETTE LEADER routine at 0296 (which reads from the cassette recorder selected in register A until the end-of-leader marker of A5H is found; and flashes the cursor while doing this).
2CA3-2CA4
Jump back to 2C47H.

2CA5-2CA9 - MESSAGE STORAGE LOCATION

2CA5-2CA9NOOKCS
DEFM "BAD"
The BAD message is stored here.

2CAA-2CB0 - LEVEL II BASIC "PEEK" ROUTINE - On entry, REG 1 to have the peek location, and on exit Reg 1 to have the peeked value.

Note: In the 8K PEEK only accepts positive numbers up to 32767.
POKE will only take an address up to 32767, no fudging allowed.
The value is unsigned.
In the extended version negative numbers can be used to refer to locations higher than 32767.
The correspondence is given by subtracting 65536 from locations higher than 32767 or by specifying a positive number up to 65535.

2CAA-2CACPEEK
Call the CONVERT TO INTEGER routine at 0A7FH (where the contents of REG 1 are converted from single or double precision to integer and deposited into HL).
2CAD
LD A,(HL)
Load register A with the value at the location of the memory pointer in HL.
2CAE-2CB0
Go save the 8-bit value in register A as the current result in REG 1.

2CB1-2CBC - LEVEL II BASIC "POKE" ROUTINE

2CB1-2CB3POKE
Go evaluate the expression at the location of the current BASIC program pointer in HL and return with the integer result in DE.
2CB4
PUSH DE
Save the address the user wants to POKE to (held in DE) to the stack.
2CB5-2CB6
RST 08H ⇒ 2EH
Since the character at the location of the current BASIC program pointer in HL must be a ,, call the COMPARE SYMBOL routine at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL register to the value in the location following the RST 08 call.
  • If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
  • If the two characters do not match, a syntax error message is given and control returns to the Input Phase).
2CB7-2CB9
GOSUB to 2B1CH to evaluate the expression at the location of the current BASIC program pointer in HL and return with the 8-bit value in register A.
2CBA
POP DE
Get the address the user wants to POKE to from the stack and put it in DE.
2CBB
LD (DE),A
Save the value the user wanted to poke (held in register A) in the location that the user wants to POKE to (held in DE).
2CBC
RET
Return.

2CBD-2E52 - LEVEL II BASIC "USING" ROUTINE

Come here after the "USING" clause in a PRINT statement is recognized.
The idea is to scan the USING string until the value list is exhausted, finding string and numeric fields to print values out of the list in, and just outputing any characters that aren't part of a print field.

2CBD-2CBFPRINUS
Go evaluate the string expression at the location of the current BASIC program pointer in HL.
2CC0-2CC2
Go make sure the expression that was just evaluated was a string.
2CC3-2CC4
RST 08H ⇒ 3BH
Since the character at the location of the current BASIC program pointer in HL must be a ";", call the COMPARE SYMBOL routine at RST 08H.

NOTE: The RST 08H routine compares the symbol in the input string pointed to by HL register to the value in the location following the RST 08 call.
  • If there is a match, control is returned to the next execution address (i.e, the RST 08H instruction + 2) with the next symbol in the A Register and HL incremented by one.
  • If the two characters do not match, a syntax error message is given and control returns to the Input Phase).
2CC5
EX DE,HL
Load DE with the value of the current BASIC program pointer in HL.
2CC6-2CC8
LD HL,(4121H)LD HL,(FACLO)
Load HL with the USING string's VARPTR.
2CC9-2CCA
Jump down to 2CD3H to continue.
2CCB-2CCDREUSST
LD A,(40DEH)LD A,(USFLG)
Load register A with the value of the READ/INPUT flag.
Note: 40DEH holds READ flag.
2CCE
OR A
Check to see if the READ/INPUT flag in register A indicates INPUT.
2CCF-2CD0
Jump down to 2CDDH if the READ/INPUT flag in register A indicates INPUT.
2CD1
POP DE
Restore the current BASIC program pointer (from the stack) into DE.
2CD2
EX DE,HL
Load HL with the value of the current BASIC program pointer in DE. D will wind up being the length of the string
2CD3INIUS
PUSH HL
Save the USING string's VARPTR in HL to the stack.
2CD4
XOR A
Zero register A.
2CD5-2CD7
LD (40DEH),ALD (USFLG),A
Clear the READ/INPUT flag.
Note: 40DEH holds READ flag.
2CD8
CP D
Check to see if the value in D is equal to zero (by checking it against A which was XOR'd to 0 above).
2CD9
PUSH AF
Save the value in AF (the difference) to the stack.
2CDA
PUSH DE
Save the value in DE (the address of the next input symbol from the code string) to the stack.
2CDB
LD B,(HL)
Load register B with the USING string's length at the location of the USING string's VARPTR in HL.
2CDC
OR B
Check to see if the USING string's length in register B is equal to zero.
2CDD-2CDFFCERR3
Display a ?FC ERROR if the USING string's length in register B is equal to zero.
2CE0
INC HL
Bump the value of the USING string's VARPTR in HL.
2CE1
LD C,(HL)
Load register C with the LSB of the USING string's address at the location of the USING string's VARPTR in HL.
2CE2
INC HL
Bump the value of the USING string's VARPTR in HL.
2CE3
LD H,(HL)
Load register H with the MSB of the USING string's address at the location of the USING string's VARPTR in HL.
2CE4
LD L,C
Load register L with the LSB of the USING string's address in register C.
2CE5-2CE6
Jump down to 2D03H to analyze the field description.
2CE7BGSTRF
LD E,B
Load register E with the USING string's length in register B.
2CE8
PUSH HL
Save the value of the current USING string pointer in HL.
2CE9-2CEA
LD C,02H
Load register C with the number of %'s substring length.
2CEBLPSTRF
LD A,(HL)
Load register A with the character at the location of the USING string pointer in HL.
2CEC
INC HL
Bump the value of the USING string pointer in HL.
2CED-2CEE
CP 25HCP CSTRNG
Check to see if the character in register A is a %.
2CEF-2CF1
Jump down to 2E17H if the character in register A is a %.
2CF2-2CF3
CP 20H
Check to see if the character in register A is a space.
2CF4-2CF5
Jump down a few opcodes to 2CF9H if the character in register A isn't a space.
2CF6
INC C
Bump the % substring length in register C.
2CF7-2CF8
Decrement the USING string's length in register B.

Since string field wasn't found, the "USING" string character count and the pointer into it's data must be restored and the "\" printed

2CF9NOSTRF
POP HL
At this point we have either exhausted the input or found a non-blank character. In either case ... get the value of the USING string pointer from the stack and put it in HL.
2CFA
LD B,E
Load register B with the USING string's length.
2CFB-2CFC
LD A,25H
Load register A with a %.

Here to print the character in [A] since it wasn't part of any field

2CFD-2CFFNEWUCH
Go print a + after printing a single % if necessary.
2D00-2D02
Go print the character in register A.
2D03PRCCHR
XOR A
Zero register A and clear the flags.
2D04
LD E,A
Zero register E.
2D05
LD D,A
Zero register D.
2D06-2D08PLSFIN
Go print a leading + if necessary.
2D09
LD D,A
Zero register D.
2D0A
LD A,(HL)
Load register A with the character (i.e., the field description) at the location of the USING string pointer in HL.
2D0B
INC HL
Bump the value of the USING string pointer in HL.
2D0C-2D0D
CP 21H
Check to see if the character in register A is a !.
2D0E-2D10
Jump if the character in register A is a !.
2D11-2D12
CP 23H
Check to see if the character in register A is a #.
2D13-2D14
Jump if the character in register A is a #.
2D15
DEC B
Decrement the value of the string's length in register B.
2D16-2D18
Jump if this is the end of the USING string.
2D19-2D1A
CP 2BH
Check to see if the character in register A is a +.
2D1B-2D1C
LD A,08H
Set the flag in register A to force a leading +.
2D1D-2D1E
Jump if the character in register A was a +.
2D1F
DEC HL
Decrement the value of the USING string pointer in HL.
2D20
LD A,(HL)
Load register A with the character at the location of the USING string pointer in HL.
2D21
INC HL
Bump the value of the USING string pointer in HL.
2D22-2D23
CP 2EH
Check to see if the character in register A is a ..
2D24-2D25
Jump if the character in register A is a ..
2D26-2D27
CP 25H
Check to see if the character in register A is a %.
2D28-2D29
Jump if the character in register A is a %.
2D2A
CP (HL)
Compare the character in register A with the character at the location of the USING string pointer in HL.
2D2B-2D2C
Jump if the character in register A isn't equal to the character at the location of the USING string pointer in HL.
2D2D-2D2E
CP 24H
Check to see if the character in register A is a $.
2D2F-2D30
Jump if the character in register A is a $.
2D31-2D32
CP 2AH
Check to see if the character in register A is a *.
2D33-2D34
Jump if the character in register A isn't a *.
2D35
LD A,B
Load register A with the USING string's length in register B.
2D36-2D37
CP 02H
Check to see if the USING string's length in register A is at least two.
2D38
INC HL
Bump the value of the USING string pointer in HL.
2D39-2D3A
Jump to 2D3EH if the USING string's length in register A isn't at least two.
2D3B
LD A,(HL)
Load register A with the character at the location of the USING string pointer in HL.
2D3C-2D3D
CP 24H
Check to see if the character in register A is a string.
2D3E-2D3FNOTSPC
LD A,20H
Set the ** edit flag in register A.
2D40-2D41
Jump if the character in register A isn't a $.
2D42
DEC B
Decrement the value of the USING string's length in register.
2D43
INC E
Bump the number of characters to the left of the decimal point in register E.
2D44-2D45
FE AF
Z-80 Trick to skip over a XOR A if passing through by processing it as a CP AFH.
2D45DOLRNM
XOR A
This is $ processing for PRINT USING.
2D46-2D47
ADD A,10H
Mask the value of the edit flag in register A for leading $'s.
2D48
INC HL
Bump the value of the USING string pointer in HL.
2D49SPCNUM
INC E
Bump the number of characters to the left of the decimal point in register E.
2D4A
ADD A,D
Combine the value of the edit flag in register D with the value of the edit flag in register A.
2D4B
LD D,A
Load register D with the value of the edit flag in register A.
2D4CNUMNUM
INC E
Bump the number of characters to the left of the decimal point in register E.
2D4D-2D4E
LD C,00H
Zero the number of characters to the right of the decimal point in register C.
2D4F
DEC B
Decrement the value of the string's length in register B.
2D50-2D51
Jump if this is the end of the string.
2D52
LD A,(HL)
Load register A with the character at the location of the USING string pointer in HL.
2D53
INC HL
Bump the value of the USING string pointer in HL.
2D54-2D55
CP 2EH
Check to see if the character in register A is a ..
2D56-2D57
Jump if the character in register A is a ..
2D58-2D59
CP 23H
Check to see if the character in register A is a #.
2D5A-2D
5BH Jump if the character in register A is a #.
2D5C-2D5D
CP 2CH
Check to see if the character in register A is a ,.
2D5E-2D5F
Jump if the character in register A isn't a ,.
2D60
LD A,D
Load register A with the value of the edit flag in register D.
2D61-2D62
OR 40H
Mask the edit flag in register A for ,.
2D63
LD D,A
Load register D with the value of the edit flag in register A.
2D64-2D65
Jump to 2D4CH.

Here when a "." is seen in the "USING" string.
It starts a numeric field if and only if it is followed by a "#"

2D66DOTNUM
LD A,(HL)
Load register A with the character at the location of the USING string pointer in HL.
2D67-2D68
CP 23H
Check to see if the character in register A is a #.
2D69-2D6A
LD A,2EH
Load register A with a decimal point.
2D6B-2D6C
Jump if the character in register A wasn't a #.
2D6D-2D6E
LD C,01H
Load register C with the number of characters to the right of the decimal point.
2D6F
INC HL
Bump the value of the USING string pointer in HL.
2D70AFTDOT
INC C
Bump the number of characters to the right of the decimal point in register C.
2D71
DEC B
Decrement the value of the string's length in register B.
2D72-2D73
Jump if this is the end of the string.
2D74
LD A,(HL)
Load register A with the character at the location of the USING string pointer in HL.
2D75
INC HL
Bump the value of the USING string pointer in HL.
2D76-2D77
CP 23H
Check to see if the character in register A is a #.
2D78-2D79
Jump if the character in register A is a #.

Check for the "^^^^" that indicates scientific notation

2D7AFINNUM
PUSH DE
Save the value of the edit flag and the count of the characters to the left of the decimal point in DE to the stack.
2D7B-2D7D
LD DE,2D97HLD DE,NOTSCI
Load DE with the return address.
2D7E
PUSH DE
Save the value of the return address in DE to the stack.
2D7F
LD D,H
Load register D with the MSB of the USING string pointer m register H.
2D80
LD E,L
Load register E with the LSB of the USING string pointer in register L.
2D81-2D82
CP 5BH
Check to see if the character in register A is an up arrow.
2D83
RET NZ
Return if the character in register A isn't an up arrow.
2D84
CP (HL)
Check to see if the character at the location of the USING string pointer in HL is an up arrow.
2D85
RET NZ
Return to 2D97 if the character at the location of the USING string pointer in HL isn't an up arrow (meaning we do not have a [[ format).
2D86
INC HL
Bump the value of the USING string pointer in HL.
2D87
CP (HL)
Check to see if there is a third up arrow at the location of the USING string pointer in HL.
2D88
RET NZ
Return to 2D97 if the character at the location of the USING string pointer in HL isn't an up arrow (meaning we do not have a [[[ format).
2D89
INC HL
Bump the value of the USING string pointer in HL.
2D8A
CP (HL)
Check to see if the character at the location of the USING string pointer in HL is a fourth up arrow.
2D8B
RET NZ
Return to 2D97 if the character at the location of the USING string pointer in HL isn't an up arrow (meaning we do not have a [[[[ format).
2D8C
INC HL
Bump the value of the USING string pointer in HL. If we are here we have a #.##[[[[ format.
2D8D
LD A,B
Load register A with the value of the USING string's length in register B.
2D8E-2D8F
SUB 04H
Check to see if there are at least 4 characters left in the USING string.
2D90
RET C
Return to 2D97 if there aren't at least four characters left in the USING string.
2D91
POP DE
If there are at least 4 characters left, then clean up the stack.
2D92
POP DE
Get the edit flag and the count of the characters to the left of the decimal point from the stack and put it in DE.
2D93
LD B,A
Load register B with the USING string's length in register A.
2D94
INC D
Set the exponential notation flag in register D.
2D95
INC HL
Bump the value of the USING string pointer in HL.
2D96
CA
Z-80 Trick! By putting the CA opcode here, the next 2 bytes are ignored if passing through, but remain in effect if jumped to.
2D97NOTSCI
EX DE,HL
(Ignored if passing through) Load HL with the value of the USING string pointer in DE.
2D98
POP DE
(Ignored if passing through) Get the edit flag and the count of the characters to the left of the decimal point from the stack and put it in DE.
2D99ENDNUS
LD A,D
Load register A with the value of the edit flag in register D.
2D9A
DEC HL
Decrement the value of the USING string pointer in HL.
2D9B
INC E
Bump the number of characters to the left of the decimal point in register E.
2D9C-2D9D
AND 08H
Check to see if the sign flag is set in register A.
2D9E-2D9F
Jump to 2DB5H if the sign flag has already been processed.
2DA0
DEC E
Decrement the number of characters to the left of the decimal point in register E.
2DA1
LD A,B
Load register A with the USING string's length in register B.
2DA2
OR A
Check to see if this is the end of the string.
2DA3-2DA4
Jump to 2DB5H if this is the end of the string.
2DA5
LD A,(HL)
Load register A with the character at the location of the USING string pointer in HL.
2DA6-2DA7
SUB 2DH
Check to see if the character in register A is a - .
2DA8-2DA9
Jump to 2DB0H if the character in register A is a - .
2DAA-2DAB
CP 0FEH
Check to see if the character in register A is a +.
2DAC-2DAD
Jump to 2DB5H if the character in register A isn't a +.
2DAE-2DAF
LD A,08H
Set the edit flag for a + character.
2DB0-2DB1SGNTRL
ADD A,04H
Set the edit flag for a - character.
2DB2
ADD A,D
Combine the value of the edit flag in register D with the value of the edit flag in register A.
2DB3
LD D,A
Load register D with the value of the edit flag in register A.
2DB4
DEC B
Decrement the value of the USING string's length in register B.
2DB5ENDNUM
POP HL
Get the value of the current BASIC program pointer from the stack and put it in HL.
2DB6
POP AF
Load register A with the character at the location of the current BASIC program pointer in HL.
2DB7-2DB8
Jump if this is the end of the BASIC statement.
2DB9
PUSH BC
Save the count of the characters to the right of the decimal point and the USING string's length in BC to the stack.
2DBA
PUSH DE
Save the edit flag and the number of characters to the left of the decimal point in DE to the stack.
2DBB-2DBD
Go evaluate the expression at the location of the current BASIC program pointer and return with the result in REG 1.
2DBE
POP DE
Get the edit flag and the number of characters to the left of the decimal point from the stack and put it in DE.
2DBF
POP BC
Get the number of characters to the right of the decimal point and the USING string's length from the stack and put it in BC.
2DC0
PUSH BC
Save the number of characters to the right of the decimal point and the USING string's length m BC to the stack.
2DC1
PUSH HL
Save the value of the current BASIC program pointer in HL to the stack.
2DC2
LD B,E
Load register B with the number of characters to the left of the decimal point in register E.
2DC3
LD A,B
Load register A with the number of characters to the left of the decimal point in register B.
2DC4
ADD A,C
Add the number of characters to the right of the decimal point in register C to the number of characters to the left of the decimal point in register A.
2DC5-2DC6
CP 19H
Check to see if the total number of characters in register A is greater than 24.
2DC7-2DC9
Display a FC ERROR message if the total number of characters in register A is greater than 24.
2DCA
LD A,D
Load register A with the value of the edit flag in register D.
2DCB-2DCC
OR 80H
Set the edit flag in register A.
2DCD-2DCF
Call the FLOATING TO ASCII routine at 0FBEH (whcih converts a single or double precision number in REG 1 to its ASCII equivalent which will be stored at the buffer pointed to by HL using the format codes in the A, B, and C registers.
2DD0-2DD2
We need to display the ASCII string, so we call the WRITE MESSAGE routine at 28A7H.
NOTE:
  • The routine at 28A7 displays the message pointed to by HL on current system output device (usually video).
  • The string to be displayed must be terminated by a byte of machine zeros or a carriage return code 0D.
  • If terminated with a carriage return, control is returned to the caller after taking the DOS exit at 41D0H (JP 5B99H).
2DD3FNSTRF
POP HL
Get the value of the current BASIC program pointer from the stack and put it in HL.
2DD4
DEC HL
Decrement the value of the current BASIC program pointer in HL.
2DD5
RST 10H
We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2DD6
SCF
Set the Carry flag.
2DD7-2DD8
Jump if the character at the location of the current BASIC program pointer in register A is an end of the BASIC statement character.
2DD9-2DDB
LD (40DEH),ALD (USFLG),A
Save the character at the location of the current BASIC program pointer in register A.
Note: 40DEH holds READ flag.
2DDC-2DDD
CP 3BH
Check to see if the character at the location of the current BASIC program pointer in register A is a semicolon.
2DDE-2DDF
Jump if the character at the location of the current BASIC program pointer in register A is a semicolon.
2DE0-2DE1
CP 2CH
Check to see if the character at the location of the current BASIC program pointer in register A is a comma.
2DE2-2DE4
Go to the Level II BASIC error routine and display an SN ERROR message if the character at the location of the current BASIC program pointer in register A isn't a comma.
2DE5SEMUSN
RST 10H
We need the next character in the BASIC program so call the EXAMINE NEXT SYMBOL routine at RST 10H.
NOTE:
  • The RST 10H routine loads the next character from the string pointed to by the HL register into the A-register and clears the CARRY flag if it is alphabetic, or sets it if is alphanumeric.
  • Blanks and control codes 09H and 0BH are ignored causing the following character to be loaded and tested.
  • The HL register will be incremented before loading any character therfore on the first call the HL register should contain the string address minus one.
  • The string must be terminated by a byte of zeros.
2DE6CRDNUS
POP BC
Get the USING string's length from the stack and put it in register B.
2DE7
EX DE,HL
Load DE with the value of the current BASIC program pointer in HL.
2DE8
POP HL
Get the USING string's VARPTR from the stack and put it in HL.
2DE9
PUSH HL
Save the USING string's VARPTR in HL to the stack.
2DEA
PUSH AF
Save the character at the location of the current BASIC program pointer in register A to the stack.
2DEB
PUSH DE
Save the value of the current BASIC program pointer in DE to the stack.

Since FRMEVL may have forced garbage collection we have to use the number of characters already scanned as an offset to the pointer to the "USING" string's data to get a new pointer to the rest of the characters to be scanned

2DEC
LD A,(HL)
Load register A with the USING string's length at the location of the USING string's VARPTR in HL.
2DED
SUB B
Compare the USING string's length in register B with the USING string's length in register A.
2DEE
INC HL
Bump the value of the USING string's VARPTR in HL.
2DEF
LD C,(HL)
Load register C with the LSB of the USING string's address at the location of the USING string's VARPTR in HL.
2DF0
INC HL
Bump the value of the USING string's VARPTR in HL.
2DF1
LD H,(HL)
Load register H with the MSB of the USING string's address at the location of the USING string's VARPTR in HL.
2DF2
LD L,C
Load register L with the LSB of the USING string's address in register C.
2DF3-2DF4
LD D,00H
Zero register D.
2DF5
LD E,A
Load register E with the USING string's offset in register A.
2DF6
ADD HL,DE
Add the USING string's offset in DE to the USING string's address in HL.
2DF7
LD A,B
Load register A with the USING string's length in register B.
2DF8
OR A
Check to see if this is the end of the USING string.
2DF9-2DFB
Jump to 2D03H if this isn't the end of the USING string.
2DFC-2DFD
Jump to 2E04H if this is the end of the USING string.
2DFE-2E00REUSIN
GOSUB to 2E49H print a + if necessary.
2E01-2E03
Go send the character in register A to the current output device.
2E04FINUSI
POP HL
Get the value of the current BASIC program pointer from the stack and put it in HL.
2E05
POP AF
Get the character at the location of the current BASIC program pointer from the stack and put it in register A.
2E06-2E08
Jump back to 2CCBH if this isn't the end of the BASIC statement.
2E09-2E0BFLDFIN
GOSUB to 20FEH to send a carriage return to the current output device if necessary.
2E0C
EX (SP),HL
Exchange the value of the current BASIC program pointer in HL with the value of the USING string's VARPTR to the stack.
2E0D-2E0F
Go get the USING string's address in DE.
2E10
POP HL
Get the value of the current BASIC program pointer from the stack and put it in HL.
2E11-2E13
Return to 2169H.

Here when the "!" indicating a single character string field has been scanned

2E14-2E15SMSTRF
LD C,01H
Continue processing a ! in the USING format by loading register C with the number of characters to be printed.
2E16-2E17
3E F1
Z-80 Trick. By putting a 3E in front of the F1 (which is POP AF, to clear the stack) that POP AF gets skipped if flowing down in the code.
2E17ISSTRF
POP AF
(Skipped if passing down) Clear the stack.
2E18
DEC B
Decrement the value of the string's length in register B.
2E19-2E1B
Go print a + if register D is not zero.
2E1C
POP HL
Get the value of the current BASIC program pointer from the stack and put it in HL.
2E1D
POP AF
Get the character at the location of the current BASIC program pointer from the stack and put it in register A.
2E1E-2E1F
Jump back to 2E09H if the character at the location of the current BASIC program pointer in register A is an end of the BASIC statement character.
2E20
PUSH BC
Save the USING string's length and the number of characters to be printed in BC to the stack.
2E21-2E23
Go evaluate the expression at the location of the current BASIC program pointer in HL and return with the result in REG 1
2E24-2E26
Go make sure the current result in REG 1 is a string.
2E27
POP BC
Get the USING string's length and the number of characters to be printed from the stack and put it in BC.
2E28
PUSH BC
Save the USING string's length and the number of characters to be printed in BC to the stack.
2E29
PUSH HL
Save the value of the current BASIC program pointer in HL to the stack.
2E2A-2E2C
LD HL,(4121H)LD HL,(FACLO)
Load HL with the string's VARPTR in REG 1.
2E2D
LD B,C
Load register B with the number of characters to be printed in register C.
2E2E-2E2F
LD C,00H
Zero register C.
2E30
PUSH BC
Save the length of the string to be printed in register B to the stack.
2E31-2E33
Go evaluate the string to be printed.
2E34-2E36
Go send the string to the current output device.
2E37-2E39
LD HL,(4121H)LD HL,(FACLO)
Load HL with the string's VARPTR in REG 1.
2E3A
POP AF
Get the length of the string to be printed from the stack and put it in register A.
2E3B
SUB (HL)
Subtract the string's length at the location of the string's VARPTR in HL from the length of the string to be printed in register A.
2E3C
LD B,A
Load register B with the number of spaces to be printed in register A.
2E3D-2EJE
LD A,20H
Load register A with a space.
2E3F
INC B
Bump the number of spaces in register B.

This loop will print all the spaces needed and then jump to 2DD3H

2E40UPRTSP
Decrement the number of spaces in register B.
2E41-2E43
Jump back to 2DD3H if all of the spaces have been printed.
2E44-2E46
Go send a space to the current output device.
2E47-2E48
Jump back to 2E40H.

When a "+" is detected in the "USING" string if a numeric field follows a bit in [D] should be set, otherwise "+" should be printed.
Since deciding whether a numeric field follows is very difficult, the bit is always set in [D].
At the point it is decided a character is not part of a numeric field, this routine is called to see if the bit in [D] is set, which means a plus preceded the character and should be printed.

2E49PLSPRT
PUSH AF
Save the value in register A to the stack.
2E4A
LD A,D
Load register A with the value in register D.
2E4B
OR A
Check to see if register A is equal to zero.
2E4C-2E4D
LD A,2BH
Load register A with a +.
2E4E-2E50
Go send a + to the current output device if register D is non-zero.
2E51
POP AF
Get the value from the stack and put it in register A.
2E52
RET
Return.

2E53-2FFA - LEVEL II BASIC "EDIT" ROUTINE

This is the EDIT <line number> command.
The EDIT command takes a single line number as its argument.
If the line does not exist, an undefined statement error is printed.
The line number of the line being edited is then typed and the user may enter one of the following edit codes to change the line.
A - Again edit the line.
All previous edits made during the edit are discarded, and editing is restarted on the line.
#C - Change the character in the line to one typed on the users terminal.
#D - Delete # characters from the line.
ISTR<ESC> - Insert the string STR at the current position in the line.
XSTR<ESC> - Prints the rest of the line and goes into insert mode (same as "I").
HSTR<ESC> - All characters to the right of the current position are deleted, and insert mode is entered.
The deleted characters are not echoed.
L - Type the remainder of the line and restart editing at the start of the line.
Q - Quit editing the line.
Any partial changes made to the line by the EDIT command are not retained, and the original line is left unchanged.
#S<CHAR> - Search forward in the line for the N'th occurance of the character <CHAR>, printing all characters passed over up to, but not including the character which terminates the search.
#K<CHAR> - Equivalent to "S" except that all characters passed over during the searche are deleted.
E - End editing the line.
The edited line replaces the orignginal line.
<CR> - Quit editing the line (print the remainder of the line).
The edited line replaces the original line.
[C] contains count of characters in line.
[B] contains current character position 0=first in line.
[H,L] point to current character

2E53-2E55ERREDT
LD (409AH),ALD (ERRFLG),A
Reset the error flag.
Note: 409AH holds the RESUME flag.
2E56-2E58
LD HL,(40EAH)LD HL,(ERRLIN)
Load HL with the line number where the error occurred.
Note: 40EAH-40EBH holds the line number with error.
2E59
OR H
OR register A with the MSB of the error line number in register H.
2E5A
AND L
Combine the LSB of the error line number in register L with the MSB of the error line number in register A. It will be FFH if execution had not begun.
2E5B
INC A
Bump the combined value of the error line number in register A. If execution had not begin, this will turn A from FFH into 00H
2E5C
EX DE,HL
Load DE with the line number with the error (held in HL).
2E5D
RET Z
If there was no line number, return if Level II BASIC.
2E5E-2E5F
Jump to 2E64H.

Now that the above code is out of the way (it was the code which would enter EDIT if there was an error in a line number), let us actually process the EDIT command.

2E60-2E62EDIT
Get the first line number by calling 1E4F - returns in in DE.
2E63
RET NZ
If the zero flag got set, there was no line number, so return.
2E64EREDIT
POP HL
Clean up the stack.
2E65EEDITS
EX DE,HL
Load HL with the line number to be edited in DE.
2E66-2E68
LD (40ECH),HLLD (DOT),HL
Save the value of the line number to be edited (in HL) to the memory location that cares about such things.
Note: 40ECH-40EDH holds EDIT line number.
2E69
EX DE,HL
Load DE with the line number to be edited in HL.
2E6A-2E6C
Call the SEARCH FOR LINE NUMBER routine at 1B2CH which looks for the line number specified in DE. Returns C/Z with the line found in BC, NC/Z with line number is too large and HL/BC having the next available location, or NC/NZ with line number not found, and BC has the first available one after that.
2E6D-2E6F
If the BASIC line number doesn't exist, display a ?UL ERROR.
2E70
LD H,B
At this point, the line number has been found. Load register H with the MSB of the memory pointer in register B.
2E71
LD L,C
Load register L with the LSB of the memory pointer in register C.
2E72
INC HL
Bump the value of the memory pointer in HL.
2E73
INC HL
Bump the value of the memory pointer in HL.
2E74
LD C,(HL)
Load register C with the LSB of the BASIC line number at the location of the memory pointer in HL.
2E75
INC HL
Bump the value of the memory pointer in HL.
2E76
LD B,(HL)
Load register B with the MSB of the BASIC line number at the location of the memory pointer in HL.
2E77
INC HL
Bump the value of the memory pointer in HL.
2E78
PUSH BC
Save the value of the BASIC line number in BC to the stack.
2E79-2E7B
Go move the BASIC line we are working on into the input buffer and expand it.
2E7CLLED
POP HL
Get the value of the BASIC line number from the stack and put it in HL.
2E7DINLED
PUSH HL
Save the value of the BASIC line number in HL to the stack.
2E7E-2E80
Convert the line number to ASCII and print it out by calling the HL TO ASCII routine at 0FAFH (which converts the value in the HL (assumed to be an integer) to ASCII and display it at the current cursor position on the video screen).
2E81-2E82
LD A,20H
Load register A with a space.
2E83-2E85
Go display the space in register A.
2E86-2E88
LD HL,(40A7H)LD HL,(BUFPNT)
Load HL with the starting address of the expended version of the current line from the input buffer.
Note: 40A7H-40A8H holds the input Buffer pointer.
2E89-2E8A
LD A,0EH
Load register A with the "turn on the cursor" character.
2E8B-2E8D
Go turn on the cursor.
2E8E
PUSH HL
Save the value of the input buffer pointer (in HL) to the stack.
2E8F-2E90
LD C,FFH
Load register C with the number of characters examined so far with FFH because the next line is going to INC it by 1 to make it 0.
2E91LENLP
INC C
Bump the number of characters examined so far in register C.
2E92
LD A,(HL)
Load register A with the character at the location of the input buffer pointer in HL.
2E93
OR A
Check to see if the character in register A is an end of the BASIC line character.
2E94
INC HL
Bump the value of the input buffer pointer in HL.
2E95-2E96
Loop back to 2E91H until the end of the BASIC line has been found.
2E97
POP HL
At this point, C will be the maximum number of characters in the line at issue. Put the start of the expended buffer into HL.
2E98
LD B,A
Zero register B. B will ultimately contain the count of characters inserted.
2E99-2E9ADISPED
LD D,00H
Zero register D.
2E9B-2E9DDISPI
Go scan the keyboard.
2D9E-2E9FDISP
SUB 30H
We need to test to see if the character was alphabetic or alphanumeric so we subtract 30H from it.
2EA0-2EA1
Jump down to 2EB0H if the character in register A is alphabetic.
2EA2-2EA3
CP 0AH
Check to see if the character is register A is numeric.
2EA4-2EA5
Jump to 2EB0H if the character in register A isn't numeric.
2EA6
LD E,A
Load register E with the binary value of the character in register A.
2EA7
LD A,D
Load register A with the value in register D.
2EA8
RLCA
Multiply the value in register A by two (so now A has multiplied by 2).
2EA9
RLCA
Multiply the value in register A by two (so now A has multiplied by 4).
2EAA
ADD A,D
Add the value in register D to the value in register A (so now A has multiplied by 5).
2EAB
RLCA
Multiply the value in register A by two (so now A has multiplied by 10).
2EAC
ADD A,E
Add the value in register E to the value in register A.
2EAD
LD D,A
Load register D with the value in register A.
2EAE-2EAF
Loop until a nonnumeric character is pressed.
2EB0NOTDGI
PUSH HL
Save the value of the input buffer pointer in HL to the stack.
2EB1-2EB3
LD HL,2E99HLD HL,DISPED
Load HL with the return address of 2E99H.
2EB4
EX (SP),HL
Exchange the value of the return address in HL with the value of the input buffer pointer to the stack.
2EB5
DEC D
We need to test if the command was preceded by a number so we need to set the flags by first ... decrementing the numeric value in register D ...
2EB6
INC D
... and then incrementing the numeric value in register D.
2EB7-2EB9
Jump to 2EBBH if a numeric value preceded the command (i.e., register D isn't equal to zero).
2EBA
INC D
Load register D with a one.
2EBB-2EBCNTZERD
CP 0D8H
Check to see if the character in register A is a backspace character.
2EBD-2EBF
Jump if the character in register A is a backspace character.
2EC0-2EC1
CP 0DDH
Check to see if the character in register A is a carriage return.
2EC2-2EC4
Jump if the character in register A is a carriage return.
2EC5-2EC6
CP 0F0H
Check to see if the character in register A is a space.
2EC7-2EC8
Jump if the character in register A is a space.
2EC9-2ECA
CP 31H
Check to see if the character in register A is lowercase.
2ECB-2ECC
Jump if the character in register A isn't lowercase.
2ECD-2ECE
SUB 20H
Convert the lowercase character in register A to uppercase.
2ECF-2ED0NOTLW4
CP 21H
Check to see if the character in register A is a Q.
2ED1-2ED3
Jump if the character in register A is a Q.
2ED4-2ED5
CP 1CH
Check to see if the character in register A is an L.
2ED6-2ED7
Jump if the character in register A is an L.
2ED9-2EDA
CP 23H
Check to see if the character in register A is an S.
2EDB-2EDC
Jump if the character in register A is an S.
2EDD-2EDE
CP 19H
Check to see if the character in register A is an I.
2EDF-2EE1
Jump if the character in register A is an I.
2EE2-2EE3
CP 14H
Check to see if the character in register A is a D.
2EE4-2EE6
Jump if the character in register A is a D.
2EE7-2EE8
CP 13H
Check to see if the character in register A is a C.
2EE9-2EEB
Jump if the character in register A is a C.
2EEC-2EED
CP 15H
Check to see if the character in register A is an E.
2EEE-2EF0
Jump if the character in register A is an E.
2EF1-2EF2
CP 28H
Check to see if the character in register A is an X.
2EF3-2EF5
Jump if the character in register A is an X.
2EF6-2EF7
CP 1BH
Check to see if the character in register A is a K.
2EF8-2EF9
Jump if the character in register A is a K.
2EFA-2EFB
CP 18H
Check to see if the character in register A is an H.
2EFC-2EFE
Jump if the character in register A is an H.
2EFF-2F00
CP 11H
Check to see if the character in register A is an A.
2F01
RET NZ
Return if the character in register A isn't an A.

2F02 - "EDIT" Command - Cancel and Restore Logic.

2F02
POP BC
Clean up the stack.
2F03
POP DE
Get the BASIC line number from the stack and put it in DE.
2F04-2F06
Go print a carriage return on the video display if necessary.
2F07-2F09
Jump back to 2E65H to re-enter the EDIT routine.

2F0A - This routine prints a string of text to the display, printer or tape.

This routin uses 032AH to do this. HL must point to the first character of the string. (409CH must be set before calling this routine, see 32AH). String must be delimited with a zero byte.
Note: 409CH holds the current output device flag: -1=cassette, 0=video and 1=printer.

2F0ASPED
LD A,(HL)
Load register A with the character at the location of the input buffer pointer in HL.
2F0B
OR A
Check to see if the character in register A is an end of the BASIC line character.
2F0C
RET Z
Return if the character in register A is an end of the BASIC line character.
2F0D
INC B
Bump the character position in register B.
2F0E-2F10
Go display the character in register A.
2F11
INC HL
Bump the value of the input buffer pointer in HL.
2F12
DEC D
Decrement the number of times to perform the operation in register D.
2F13-2F14
Loop until done.
2F15
RET
Return.

2F16 - "EDIT" Command - KILL Logic.

2F16KED
PUSH HL
Save the value of the input buffer pointer in HL to the stack.
2F17-2F19
LD HL,2F5FHLD HL,TYPSLH
Load HL with the return address of 2F5FH (which will print the final !).
2F1A
EX (SP),HL
Exchange the value of the return address in HL with the value of the input buffer pointer to the stack.
2F1B
SCF
Set the KILL/SEARCH flag for KILL since CARRY flag signals KILL.
2F1CSED
PUSH AF
Save the KILL/SEARCH flag to the stack.
2F1D-2F1F
Go scan the keyboard for the character to locate.
2F20
LD E,A
Load register E with the character to locate in register A.
2F21
POP AF
Get the KILL/SEARCH flag from the stack.
2F22
PUSH AF
Save the KILL/SEARCH flag to the stack.
2F23-2F25
If KILL (because the CARRY flag was set) then GOSUB to 2F5FH to print a !.
2F26SRCALP
LD A,(HL)
Load register A with the character at the location of the input buffer pointer in HL.
2F27
OR A
Check to see if the character in register A is an end of the BASIC line character.
2F28-2F2A
Jump down to 2F3EH if the character in register A is an end of the BASIC line character.
2F2B-2F2D
Go display the character in register A.
2F2E
POP AF
Get the KILL/SEARCH flag from the stack.
2F2F
PUSH AF
Save the KILL/SEARCH flag to the stack.
2F30-2F32
If the CARRY flag is set, that means we are in KILL mode so GOSUB to 2FA1H to delete the character from the input buffer.
2F33-2F34
Jump to 2F37H if KILL.
2F35
INC HL
If we are here, it must be SEARCH! So bump to the next character.
2F36
INC B
Bump the value of the character position counter in register B.
2F37NOTSRC
LD A,(HL)
Regardless of whether we are SEARCH or KILL, load register A with the character at the location of the current input buffer pointer in HL.
2F38
CP E
Check to see if the character in register A is the same as the character to be located in register E.
2F39-2F3A
Loop back to 2F26H until the character to be located is found.
2F3B
DEC D
Decrement the number of times to perform the operation in register D.
2F3C-2F3D
Loop until done.
2F3EPOPART
POP AF
Get the KILL/SEARCH flag from the stack.
2F3F
RET
Return.

2F40 - "EDIT" Command - LIST Logic.

2F40-2F42LED
Since we need to display the line being edited we call the PRINT MESSAGE routine at 2B75H which writes string pointed to by HL to the current output device..
2F43-2F45
Go display a carriage return if necessary.
2F46
POP BC
Get the BASIC line number from the stack and put it in BC.
2F47-2F49
Jump to 2E7CH (to print the current line number and await the next EDIT command).

2F4A - "EDIT" Command - DELETE Logic.

2F4ADED
LD A,(HL)
Load register A with the character at the location of the input buffer pointer in HL.
2F4B
OR A
Check to see if the character in register A is an end of the BASIC line character.
2F5C
RET Z
Return if the character in register A is an end of the BASIC line character.
2F4D-2F4E
LD A,21H
Load register A with an !.
2F4F-2F51
Go display the ! in register A.
2F52DELLP
LD A,(HL)
Load register A with the character at the location of the input buffer pointer in HL.
2F53
OR A
Check to see if the character in register A is an end of the BASIC line character.
2F54-2F5B
Jump to 2F5FH if the character in register A is an end of the BASIC line character.
2F56-2F58
Go display the character in register A.
2F59-2F5B
Go delete the character from the input buffer.
2F5C
DEC D
Decrement the number of times to perform the operation in register D.
2F5D-2F5E
Loop until done.
2F5F-2F60TYPSLH
LD A,21H
Load register A with an !.
2F61-2F63
Go display the ! in register A.
2F64
RET
Return.

2F65 - "EDIT" Command - CHANGE Logic.

2F65CED
LD A,(HL)
Load register A with the character at the location of the input buffer pointer in HL.
2F66
OR A
Check to see if the character in register A is an end of the BASIC line character.
2F67
RET Z
Return if the character in register A is an end of the BASIC line character.
2F68-2F6A
Go get the character to put in the input buffer from the keyboard.
2F6B
LD (HL),A
Save the character in register A at the memory location of the input buffer pointer in HL.
2F6C-2F6E
Go display the character in register A.
2F6F
INC HL
Bump the value of the input buffer pointer in HL.
2F70
INC B
Bump the character position in register B.
2F71
DEC D
Decrement the number of times to perform the operation in register D.
2F72-2F73
Loop until done.
2F74
RET
Return.

2F75 - "EDIT" Command - HACK/INSERT Logic.

2F75-2F76HED
LD (HL),00H
Zero the location of the input buffer pointer in HL.
2F77
LD C,B
Load register C with the character position in register B.
2F78-2F79XED
LD D,0FFH
Load register D with the number of times to perform the operation.

Now fall into the INSERT code

2F7A-2F7C
GOSUB to 2F0AH to display the register BASIC line if necessary.
2F7D-2F7FIED
Go get the character to be inserted from the keyboard.
2F80
OR A
Check to see if a key was pressed.
2F81-2F83
Loop back to 2F7DH until a key is pressed.
2F84-2F85
CP 08H
Check to see if the character in register A is a backspace character.
2F86-2F87
Jump to 2F92H if the character in register A is a backspace character.
2F88-2F89
CP 0DH
Check to see if the character in register A is a carriage return.
2F8A-2F8C
Jump to 2FE0H if the character in register A is a carriage return.
2F8D-2F8E
CP 1BH
Check to see if the character in register A is a shift up arrow.
2F8F
RET Z
Return if the character in register A is shift up arrow.
2F90-2F91
Jump to 2FB0H to ass the new character to the current line.

2F92 - "EDIT" Command - BACKSPACE CURSOR Logic.

2F92-2F93TYPARW
LD A,08H
Load register A with a backspace the cursor character.
2F94TYPAR1
DEC B
Decrement the character position in register B.
2F95
INC B
Bump the character position in register B.
2F96-2F97
Jump forward to 2FB7H if this is the first character of the BASIC line.
2F98-2F9A
Go backspace the cursor on the video display.
2F9B
DEC HL
Decrement the value of the input buffer pointer in HL.
2F9C
DEC B
Decrement the character position in register B.
2F9D-2F9F
LD DE,2F7DHLD DE,IED
Load DE with a return address of 2F7DH.
2FA0
PUSH DE
Save the value of the return address in DE to the stack.

Subroutine to delete char pointed to by [H,L]. Corrects C.

2FA1DELCHR
PUSH HL
Save the value of the input buffer pointer in HL to the stack.
2FA2
DEC C
Decrement the character position in register C.
2FA3CMPRSS
LD A,(HL)
Load register A with the character at the location of the input buffer pointer in HL.
2FA4
OR A
Check to see if the character in register A is an end of the BASIC line character.
2FA5
SCF
Set the Carry flag to signal that the character was deleted.
2FA6-2FA8
Jump to 0890H if the character in register A is an end of the BASIC line character.
2FA9
INC HL
Bump the value of the input buffer pointer in HL.
2FAA
LD A,(HL)
Load register A with the character at the location of the input buffer pointer in HL.
2FAB
DEC HL
Decrement the value of the input buffer pointer in HL.
2FAC
LD (HL),A
Save the character in register A at the location of the current input buffer pointer in HL.
2FAD
INC HL
Bump the value of the input buffer pointer in HL.
2FAE-2FAF
Loop back to 2FA3H until the line has been moved down.

2FB0 - "EDIT" Command - ADD A CHARACTER Logic.

2FB0NTARRW
PUSH AF
Save the character to be inserted in register A to the stack.
2FB1
LD A,C
Load register A with the number of characters in the input buffer in register C.
2FB2-2FB3
CP FFHCP BUFLEN
Check for the maximum BASIC line length.
2FB4-2FB5
Jump forward to 2FB9H if the maximum BASIC line length hasn't been reached.
2FB6
POP AF
Get the character to be inserted from the stack and put it in register A.
2FB7-2FB8DINGI
Jump back to 2F7DH.
2FB9OKINS
SUB B
Subtract the character position in register B from the number of characters in the input buffer in register A. This should give the current byte position.
2FBA
INC C
Bump the number of characters in the input buffer in register C.
2FBB
INC B
Bump the character position in register B.
2FBC
PUSH BC
Save the character position and the number of characters in the input buffer in BC to the stack.
2FBD
EX DE,HL
Load DE with the input buffer pointer in HL.
2FBE
LD L,A
Load register L with the character count in register A.
2FBF-2FC0
LD H,00H
Zero register H.
2FC1
ADD HL,DE
Add the value of the input buffer pointer in DE to the character count in HL.
2FC2
LD B,H
Load register B with the MSB of the end of the BASIC line pointer in register H.
2FC3
LD C,L
Load register C with the LSB of the end of the BASIC line pointer in register L.
2FC4
INC HL
Bump the value of the end of the BASIC line pointer in HL.
2FC5-2FC7
Go move the BASIC line up one character.
2FC8
POP BC
Get the character position and the number of characters in the input buffer from the stack and put it in BC.
2FC9
POP AF
Get the character to be inserted from the stack and put it in register A.
2FCA
LD (HL),A
Save the character in register A at the location of the current input buffer pointer in HL.
2FCB-2FCD
Go display the character in register A.
2FCE
INC HL
Bump the value of the input buffer pointer in HL.
2FCF-2FD1
Jump back to 2F7DH.

2FD2 - "EDIT" Command - BACKSPACE Logic.

2FD2DELED
LD A,B
Load register A with the number of times to backspace in register B.
2FD3
OR A
Check to see if this is the start of the BASIC line.
2FD4
RET Z
Return if this is the start of the BASIC line.
2FD5
DEC B
Decrement the character position in register B.
2FD6
DEC HL
Decrement the value of the input buffer pointer in HL.
2FD7-2FD8
LD A,08H
Load register A with a backspace the cursor character.
2FD9-2FDB
Go backspace the cursor on the video display.
2FDC
DEC D
Decrement the number of times to perform the operation in register D.
2FDD-2FDE
Loop until done.
2FDF
RET
Return.
2FE0-2FE2CRED
Since we need to display the rest of the BASIC line, we call the PRINT MESSAGE routine at 2B75H which writes string pointed to by HL to the current output device..
2FE3-2FESEED
Go display a carriage return if necessary.
2FE6
POP BC
Clean up the stack.
2FE7
POP DE
Get the BASIC line number (in binary) from the stack and put it in DE.
2FE8
LD A,D
Load register A with the MSB of the BASIC line number in register D.
2FE9
AND E
Combine the LSB of the BASIC line number in register E with the MSB of the BASIC line number in register A.
2FEA
INC A
Bump the combined BASIC line number in register A.
2FEB-2FEDEDITRT
LD HL,(40A7H)LD HL,(BUFPNT)
Load HL with the starting address of the input buffer.
Note: 40A7H-40A8H holds the input Buffer pointer.
2FEE
DEC HL
Decrement the value of the input buffer pointer in HL.
2FEF
RET Z
Return if this is the Level II BASIC command mode.
2FF0
SCF
Set the Carry flag to signal a BASIC program statement.
2FF1
INC HL
Bump the value of the input buffer pointer in HL.
2FF2
PUSH AF
Save the command mode flag in AF to the stack.
2FF3-2FF5
Jump to the Level II BASIC READY routine.

2FF6 - "EDIT" Command - QUIT Logic.

2FF6QED
POP BC
Clean up the stack.
2FF7
POP DE
Get the BASIC line number from the stack and put it in DE.
2FF8-2FFA
Jump to the Level II BASIC READY routine.
2FFB-2FFF
DE C3 C3 44 B2
Garbage Code.